admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Reland "Added BBR network controller."

Browse Source 
This is a reland of 8ac9bb4d52a687b34158dc52c8c25830b23b8333

Original change's description:
> Added BBR network controller.
> 
> BBR is a congestion control method that is initially developed for TCP.
> This CL adds an implementation of BBR ported from QUIC for use with
> WebRTC. An upcoming CL enables it via a field trial.
> 
> Bug: webrtc:8415
> Change-Id: Ie4261d2e43bafa15aa928a7cadcfec256107cdbc
> Reviewed-on: https://webrtc-review.googlesource.com/39788
> Commit-Queue: Sebastian Jansson <srte@webrtc.org>
> Reviewed-by: Philip Eliasson <philipel@webrtc.org>
> Cr-Commit-Position: refs/heads/master@{#22647}

Bug: webrtc:8415
Change-Id: I090e4116d1f470acbd64af31520654e1bd8dfcda
Reviewed-on: https://webrtc-review.googlesource.com/65200
Commit-Queue: Sebastian Jansson <srte@webrtc.org>
Reviewed-by: Philip Eliasson <philipel@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#22766}
This commit is contained in:
Sebastian Jansson 2018-04-06 11:19:50 +02:00 committed by Commit Bot
parent 66f1e9eb34
commit ac6475e031
8 changed files with 1540 additions and 19 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

39
modules/congestion_controller/bbr/BUILD.gn
View File

@ -8,7 +8,37 @@
import("../../../webrtc.gni")
rtc_static_library("bbr") {
sources = [
"bbr_factory.cc",
"bbr_factory.h",
]
deps = [
":bbr_controller",
"../../../rtc_base:rtc_base_approved",
"../network_control",
]
}
rtc_source_set("bbr_controller") {
visibility = [ ":*" ]
sources = [
"bbr_network_controller.cc",
"bbr_network_controller.h",
]
deps = [
":data_transfer_tracker",
":rtt_stats",
":windowed_filter",
"../../../api:optional",
"../../../rtc_base:checks",
"../../../rtc_base:rtc_base_approved",
"../../../rtc_base/system:fallthrough",
"../network_control",
]
}
rtc_source_set("data_transfer_tracker") {
visibility = [ ":*" ]
sources = [
"data_transfer_tracker.cc",
"data_transfer_tracker.h",
@ -20,6 +50,7 @@ rtc_source_set("data_transfer_tracker") {
]
}
rtc_source_set("rtt_stats") {
visibility = [ ":*" ]
sources = [
"rtt_stats.cc",
"rtt_stats.h",
@ -30,6 +61,7 @@ rtc_source_set("rtt_stats") {
]
}
rtc_source_set("windowed_filter") {
visibility = [ ":*" ]
sources = [
"windowed_filter.h",
]
@ -38,11 +70,14 @@ if (rtc_include_tests) {
rtc_source_set("bbr_unittests") {
testonly = true
sources = [
"bbr_network_controller_unittest.cc",
"data_transfer_tracker_unittest.cc",
"rtt_stats_unittest.cc",
"windowed_filter_unittest.cc",
]
deps = [
":bbr",
":bbr_controller",
":data_transfer_tracker",
":rtt_stats",
":windowed_filter",
@ -50,5 +85,9 @@ if (rtc_include_tests) {
"../network_control",
"../network_control:network_control_test",
]
if (!build_with_chromium && is_clang) {
# Suppress warnings from the Chromium Clang plugin (bugs.webrtc.org/163).
suppressed_configs += [ "//build/config/clang:find_bad_constructs" ]
}
}
}

31
modules/congestion_controller/bbr/bbr_factory.cc Normal file
View File

@ -0,0 +1,31 @@
/*
* Copyright (c) 2018 The WebRTC project authors. All Rights Reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#include "modules/congestion_controller/bbr/bbr_factory.h"
#include <memory>
#include "modules/congestion_controller/bbr/bbr_network_controller.h"
#include "rtc_base/ptr_util.h"
namespace webrtc {
BbrNetworkControllerFactory::BbrNetworkControllerFactory() {}
std::unique_ptr<NetworkControllerInterface> BbrNetworkControllerFactory::Create(
NetworkControllerObserver* observer,
NetworkControllerConfig config) {
return rtc::MakeUnique<bbr::BbrNetworkController>(observer, config);
}
TimeDelta BbrNetworkControllerFactory::GetProcessInterval() const {
return TimeDelta::PlusInfinity();
}
} // namespace webrtc

30
modules/congestion_controller/bbr/bbr_factory.h Normal file
View File

@ -0,0 +1,30 @@
/*
* Copyright (c) 2018 The WebRTC project authors. All Rights Reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#ifndef MODULES_CONGESTION_CONTROLLER_BBR_BBR_FACTORY_H_
#define MODULES_CONGESTION_CONTROLLER_BBR_BBR_FACTORY_H_
#include <memory>
#include "modules/congestion_controller/network_control/include/network_control.h"
namespace webrtc {
class BbrNetworkControllerFactory : public NetworkControllerFactoryInterface {
public:
BbrNetworkControllerFactory();
std::unique_ptr<NetworkControllerInterface> Create(
NetworkControllerObserver* observer,
NetworkControllerConfig config) override;
TimeDelta GetProcessInterval() const override;
};
} // namespace webrtc
#endif // MODULES_CONGESTION_CONTROLLER_BBR_BBR_FACTORY_H_

870
modules/congestion_controller/bbr/bbr_network_controller.cc Normal file
View File

@ -0,0 +1,870 @@
/*
* Copyright (c) 2018 The WebRTC project authors. All Rights Reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#include "modules/congestion_controller/bbr/bbr_network_controller.h"
#include <algorithm>
#include <array>
#include <string>
#include <vector>
#include "modules/congestion_controller/network_control/include/network_units.h"
#include "modules/congestion_controller/network_control/include/network_units_to_string.h"
#include "rtc_base/checks.h"
#include "rtc_base/logging.h"
#include "rtc_base/system/fallthrough.h"
namespace webrtc {
namespace bbr {
namespace {
// If greater than zero, mean RTT variation is multiplied by the specified
// factor and added to the congestion window limit.
const double kBbrRttVariationWeight = 0.0f;
// Congestion window gain for QUIC BBR during PROBE_BW phase.
const double kProbeBWCongestionWindowGain = 2.0f;
// The maximum packet size of any QUIC packet, based on ethernet's max size,
// minus the IP and UDP headers. IPv6 has a 40 byte header, UDP adds an
// additional 8 bytes. This is a total overhead of 48 bytes. Ethernet's
// max packet size is 1500 bytes, 1500 - 48 = 1452.
const DataSize kMaxPacketSize = DataSize::bytes(1452);
// Default maximum packet size used in the Linux TCP implementation.
// Used in QUIC for congestion window computations in bytes.
const DataSize kDefaultTCPMSS = DataSize::bytes(1460);
// Constants based on TCP defaults.
const DataSize kMaxSegmentSize = kDefaultTCPMSS;
// The minimum CWND to ensure delayed acks don't reduce bandwidth measurements.
// Does not inflate the pacing rate.
const DataSize kMinimumCongestionWindow = DataSize::bytes(1000);
// The gain used for the slow start, equal to 2/ln(2).
const double kHighGain = 2.885f;
// The gain used in STARTUP after loss has been detected.
// 1.5 is enough to allow for 25% exogenous loss and still observe a 25% growth
// in measured bandwidth.
const double kStartupAfterLossGain = 1.5;
// The gain used to drain the queue after the slow start.
const double kDrainGain = 1.f / kHighGain;
// The length of the gain cycle.
const size_t kGainCycleLength = 8;
// The size of the bandwidth filter window, in round-trips.
const BbrRoundTripCount kBandwidthWindowSize = kGainCycleLength + 2;
// The time after which the current min_rtt value expires.
const TimeDelta kMinRttExpiry = TimeDelta::seconds(10);
// The minimum time the connection can spend in PROBE_RTT mode.
const TimeDelta kProbeRttTime = TimeDelta::ms(200);
// If the bandwidth does not increase by the factor of |kStartupGrowthTarget|
// within |kRoundTripsWithoutGrowthBeforeExitingStartup| rounds, the connection
// will exit the STARTUP mode.
const double kStartupGrowthTarget = 1.25;
// Coefficient of target congestion window to use when basing PROBE_RTT on BDP.
const double kModerateProbeRttMultiplier = 0.75;
// Coefficient to determine if a new RTT is sufficiently similar to min_rtt that
// we don't need to enter PROBE_RTT.
const double kSimilarMinRttThreshold = 1.125;
const TimeDelta kInitialRtt = TimeDelta::ms(200);
const DataRate kInitialBandwidth = DataRate::kbps(300);
const TimeDelta kMaxRtt = TimeDelta::ms(1000);
const DataRate kMaxBandwidth = DataRate::kbps(5000);
const DataSize kInitialCongestionWindow = kInitialRtt * kInitialBandwidth;
const DataSize kDefaultMaxCongestionWindow = kMaxRtt * kMaxBandwidth;
static std::string ModeToString(BbrNetworkController::Mode mode) {
switch (mode) {
case BbrNetworkController::STARTUP:
return "STARTUP";
case BbrNetworkController::DRAIN:
return "DRAIN";
case BbrNetworkController::PROBE_BW:
return "PROBE_BW";
case BbrNetworkController::PROBE_RTT:
return "PROBE_RTT";
}
return "???";
}
} // namespace
BbrNetworkController::BbrControllerConfig
BbrNetworkController::BbrControllerConfig::DefaultConfig() {
BbrControllerConfig config;
config.probe_bw_pacing_gain_offset = 0.25;
config.encoder_rate_gain = 1;
config.encoder_rate_gain_in_probe_rtt = 1;
config.exit_startup_rtt_threshold_ms = 0;
config.probe_rtt_congestion_window_gain = 0.75;
config.exit_startup_on_loss = true;
config.num_startup_rtts = 3;
config.rate_based_recovery = false;
config.max_aggregation_bytes_multiplier = 0;
config.slower_startup = false;
config.rate_based_startup = false;
config.fully_drain_queue = false;
config.initial_conservation_in_startup = CONSERVATION;
config.max_ack_height_window_multiplier = 1;
config.probe_rtt_based_on_bdp = false;
config.probe_rtt_skipped_if_similar_rtt = false;
config.probe_rtt_disabled_if_app_limited = false;
return config;
}
BbrNetworkController::DebugState::DebugState(const BbrNetworkController& sender)
: mode(sender.mode_),
max_bandwidth(sender.max_bandwidth_.GetBest()),
round_trip_count(sender.round_trip_count_),
gain_cycle_index(sender.cycle_current_offset_),
congestion_window(sender.congestion_window_),
is_at_full_bandwidth(sender.is_at_full_bandwidth_),
bandwidth_at_last_round(sender.bandwidth_at_last_round_),
rounds_without_bandwidth_gain(sender.rounds_without_bandwidth_gain_),
min_rtt(sender.min_rtt_),
min_rtt_timestamp(sender.min_rtt_timestamp_),
recovery_state(sender.recovery_state_),
recovery_window(sender.recovery_window_),
last_sample_is_app_limited(sender.last_sample_is_app_limited_),
end_of_app_limited_phase(sender.end_of_app_limited_phase_) {}
BbrNetworkController::DebugState::DebugState(const DebugState& state) = default;
BbrNetworkController::BbrNetworkController(NetworkControllerObserver* observer,
NetworkControllerConfig config)
: observer_(observer),
random_(10),
max_bandwidth_(kBandwidthWindowSize, DataRate::Zero(), 0),
default_bandwidth_(kInitialBandwidth),
max_ack_height_(kBandwidthWindowSize, DataSize::Zero(), 0),
congestion_window_(kInitialCongestionWindow),
initial_congestion_window_(kInitialCongestionWindow),
max_congestion_window_(kDefaultMaxCongestionWindow),
congestion_window_gain_constant_(kProbeBWCongestionWindowGain),
rtt_variance_weight_(kBbrRttVariationWeight),
recovery_window_(max_congestion_window_) {
config_ = BbrControllerConfig::DefaultConfig();
if (config.starting_bandwidth.IsFinite())
default_bandwidth_ = config.starting_bandwidth;
constraints_ = config.constraints;
Reset();
EnterStartupMode();
SignalUpdatedRates(config.constraints.at_time);
}
BbrNetworkController::~BbrNetworkController() {}
void BbrNetworkController::Reset() {
round_trip_count_ = 0;
rounds_without_bandwidth_gain_ = 0;
is_at_full_bandwidth_ = false;
last_update_state_.mode = Mode::STARTUP;
last_update_state_.bandwidth = DataRate();
last_update_state_.rtt = TimeDelta();
last_update_state_.pacing_rate = DataRate();
last_update_state_.target_rate = DataRate();
last_update_state_.probing_for_bandwidth = false;
EnterStartupMode();
}
void BbrNetworkController::SignalUpdatedRates(Timestamp at_time) {
DataRate bandwidth = BandwidthEstimate();
if (bandwidth.IsZero())
bandwidth = default_bandwidth_;
TimeDelta rtt = GetMinRtt();
DataRate pacing_rate = PacingRate();
DataRate target_rate = bandwidth;
if (mode_ == PROBE_RTT)
target_rate = bandwidth * config_.encoder_rate_gain_in_probe_rtt;
else
target_rate = bandwidth * config_.encoder_rate_gain;
target_rate = std::min(target_rate, pacing_rate);
if (constraints_) {
target_rate = std::min(target_rate, constraints_->max_data_rate);
target_rate = std::max(target_rate, constraints_->min_data_rate);
}
bool probing_for_bandwidth = IsProbingForMoreBandwidth();
if (last_update_state_.mode == mode_ &&
last_update_state_.bandwidth == bandwidth &&
last_update_state_.rtt == rtt &&
last_update_state_.pacing_rate == pacing_rate &&
last_update_state_.target_rate == target_rate &&
last_update_state_.probing_for_bandwidth == probing_for_bandwidth)
return;
last_update_state_.mode = mode_;
last_update_state_.bandwidth = bandwidth;
last_update_state_.rtt = rtt;
last_update_state_.pacing_rate = pacing_rate;
last_update_state_.target_rate = target_rate;
last_update_state_.probing_for_bandwidth = probing_for_bandwidth;
RTC_LOG(LS_INFO) << "RateUpdate, mode: " << ModeToString(mode_)
<< ", bw: " << ToString(bandwidth)
<< ", min_rtt: " << ToString(rtt)
<< ", last_rtt: " << ToString(last_rtt_)
<< ", pacing_rate: " << ToString(pacing_rate)
<< ", target_rate: " << ToString(target_rate)
<< ", Probing:" << probing_for_bandwidth
<< ", pacing_gain: " << pacing_gain_;
TargetTransferRate target_rate_msg;
target_rate_msg.network_estimate.at_time = at_time;
target_rate_msg.network_estimate.bandwidth = bandwidth;
target_rate_msg.network_estimate.round_trip_time = rtt;
// TODO(srte): Fill in fields below with proper values.
target_rate_msg.network_estimate.loss_rate_ratio = 0;
target_rate_msg.network_estimate.bwe_period = TimeDelta::Zero();
target_rate_msg.target_rate = target_rate;
target_rate_msg.at_time = at_time;
observer_->OnTargetTransferRate(target_rate_msg);
PacerConfig pacer_config;
// A small time window ensures an even pacing rate.
pacer_config.time_window = rtt * 0.25;
pacer_config.data_window = pacer_config.time_window * pacing_rate;
if (IsProbingForMoreBandwidth())
pacer_config.pad_window = pacer_config.data_window;
else
pacer_config.pad_window = DataSize::Zero();
pacer_config.at_time = at_time;
observer_->OnPacerConfig(pacer_config);
CongestionWindow congestion_window;
congestion_window.data_window = GetCongestionWindow();
observer_->OnCongestionWindow(congestion_window);
}
void BbrNetworkController::OnNetworkAvailability(NetworkAvailability msg) {
Reset();
rtt_stats_.OnConnectionMigration();
SignalUpdatedRates(msg.at_time);
}
void BbrNetworkController::OnNetworkRouteChange(NetworkRouteChange msg) {
constraints_ = msg.constraints;
Reset();
if (msg.starting_rate.IsFinite())
default_bandwidth_ = msg.starting_rate;
rtt_stats_.OnConnectionMigration();
SignalUpdatedRates(msg.at_time);
}
void BbrNetworkController::OnProcessInterval(ProcessInterval) {}
void BbrNetworkController::OnStreamsConfig(StreamsConfig msg) {}
void BbrNetworkController::OnTargetRateConstraints(TargetRateConstraints msg) {
constraints_ = msg;
SignalUpdatedRates(msg.at_time);
}
bool BbrNetworkController::InSlowStart() const {
return mode_ == STARTUP;
}
void BbrNetworkController::OnSentPacket(SentPacket msg) {
last_send_time_ = msg.send_time;
if (!aggregation_epoch_start_time_.IsInitialized()) {
aggregation_epoch_start_time_ = msg.send_time;
}
}
bool BbrNetworkController::CanSend(DataSize bytes_in_flight) {
return bytes_in_flight < GetCongestionWindow();
}
DataRate BbrNetworkController::PacingRate() const {
if (pacing_rate_.IsZero()) {
return kHighGain * initial_congestion_window_ / GetMinRtt();
}
return pacing_rate_;
}
DataRate BbrNetworkController::BandwidthEstimate() const {
return max_bandwidth_.GetBest();
}
DataSize BbrNetworkController::GetCongestionWindow() const {
if (mode_ == PROBE_RTT) {
return ProbeRttCongestionWindow();
}
if (InRecovery() && !config_.rate_based_recovery &&
!(config_.rate_based_startup && mode_ == STARTUP)) {
return std::min(congestion_window_, recovery_window_);
}
return congestion_window_;
}
double BbrNetworkController::GetPacingGain(int round_offset) const {
if (round_offset == 0)
return 1 + config_.probe_bw_pacing_gain_offset;
else if (round_offset == 1)
return 1 - config_.probe_bw_pacing_gain_offset;
else
return 1;
}
bool BbrNetworkController::InRecovery() const {
return recovery_state_ != NOT_IN_RECOVERY;
}
bool BbrNetworkController::IsProbingForMoreBandwidth() const {
return (mode_ == PROBE_BW && pacing_gain_ > 1) || mode_ == STARTUP;
}
void BbrNetworkController::OnTransportPacketsFeedback(
TransportPacketsFeedback msg) {
Timestamp feedback_recv_time = msg.feedback_time;
rtc::Optional<SentPacket> last_sent_packet =
msg.PacketsWithFeedback().back().sent_packet;
if (!last_sent_packet.has_value()) {
RTC_LOG(LS_WARNING) << "Last ack packet not in history, no RTT update";
} else {
Timestamp send_time = last_sent_packet->send_time;
TimeDelta send_delta = feedback_recv_time - send_time;
rtt_stats_.UpdateRtt(send_delta, TimeDelta::Zero(), feedback_recv_time);
}
DataSize bytes_in_flight = msg.data_in_flight;
DataSize total_acked_size = DataSize::Zero();
bool is_round_start = false;
bool min_rtt_expired = false;
std::vector<PacketResult> acked_packets = msg.ReceivedWithSendInfo();
std::vector<PacketResult> lost_packets = msg.LostWithSendInfo();
// Input the new data into the BBR model of the connection.
if (!acked_packets.empty()) {
for (const PacketResult& packet : acked_packets) {
const SentPacket& sent_packet = *packet.sent_packet;
send_ack_tracker_.AddSample(sent_packet.size, sent_packet.send_time,
msg.feedback_time);
total_acked_size += sent_packet.size;
}
Timestamp last_acked_send_time =
acked_packets.rbegin()->sent_packet->send_time;
is_round_start = UpdateRoundTripCounter(last_acked_send_time);
UpdateBandwidth(msg.feedback_time, acked_packets);
// Min rtt will be the rtt for the last packet, since all packets are acked
// at the same time.
Timestamp last_send_time = acked_packets.back().sent_packet->send_time;
min_rtt_expired = UpdateMinRtt(msg.feedback_time, last_send_time);
UpdateRecoveryState(last_acked_send_time, !lost_packets.empty(),
is_round_start);
UpdateAckAggregationBytes(msg.feedback_time, total_acked_size);
if (max_aggregation_bytes_multiplier_ > 0) {
if (msg.data_in_flight <=
1.25 * GetTargetCongestionWindow(pacing_gain_)) {
bytes_acked_since_queue_drained_ = DataSize::Zero();
} else {
bytes_acked_since_queue_drained_ += total_acked_size;
}
}
}
total_bytes_acked_ += total_acked_size;
// Handle logic specific to PROBE_BW mode.
if (mode_ == PROBE_BW) {
UpdateGainCyclePhase(msg.feedback_time, msg.prior_in_flight,
!lost_packets.empty());
}
// Handle logic specific to STARTUP and DRAIN modes.
if (is_round_start && !is_at_full_bandwidth_) {
CheckIfFullBandwidthReached();
}
MaybeExitStartupOrDrain(msg);
// Handle logic specific to PROBE_RTT.
MaybeEnterOrExitProbeRtt(msg, is_round_start, min_rtt_expired);
// Calculate number of packets acked and lost.
DataSize bytes_lost = DataSize();
for (const PacketResult& packet : lost_packets) {
bytes_lost += packet.sent_packet->size;
}
// After the model is updated, recalculate the pacing rate and congestion
// window.
CalculatePacingRate();
CalculateCongestionWindow(total_acked_size);
CalculateRecoveryWindow(total_acked_size, bytes_lost, bytes_in_flight);
SignalUpdatedRates(msg.feedback_time);
}
void BbrNetworkController::OnRemoteBitrateReport(RemoteBitrateReport msg) {}
void BbrNetworkController::OnRoundTripTimeUpdate(RoundTripTimeUpdate msg) {}
void BbrNetworkController::OnTransportLossReport(TransportLossReport msg) {}
TimeDelta BbrNetworkController::GetMinRtt() const {
return !min_rtt_.IsZero() ? min_rtt_
: TimeDelta::us(rtt_stats_.initial_rtt_us());
}
DataSize BbrNetworkController::GetTargetCongestionWindow(double gain) const {
DataSize bdp = GetMinRtt() * BandwidthEstimate();
DataSize congestion_window = gain * bdp;
// BDP estimate will be zero if no bandwidth samples are available yet.
if (congestion_window.IsZero()) {
congestion_window = gain * initial_congestion_window_;
}
return std::max(congestion_window, kMinimumCongestionWindow);
}
DataSize BbrNetworkController::ProbeRttCongestionWindow() const {
if (config_.probe_rtt_based_on_bdp) {
return GetTargetCongestionWindow(kModerateProbeRttMultiplier);
}
return kMinimumCongestionWindow;
}
void BbrNetworkController::EnterStartupMode() {
mode_ = STARTUP;
pacing_gain_ = kHighGain;
congestion_window_gain_ = kHighGain;
}
void BbrNetworkController::EnterProbeBandwidthMode(Timestamp now) {
mode_ = PROBE_BW;
congestion_window_gain_ = congestion_window_gain_constant_;
// Pick a random offset for the gain cycle out of {0, 2..7} range. 1 is
// excluded because in that case increased gain and decreased gain would not
// follow each other.
cycle_current_offset_ = random_.Rand(kGainCycleLength - 1);
if (cycle_current_offset_ >= 1) {
cycle_current_offset_ += 1;
}
last_cycle_start_ = now;
pacing_gain_ = GetPacingGain(cycle_current_offset_);
}
bool BbrNetworkController::UpdateRoundTripCounter(
Timestamp last_acked_send_time) {
if (last_acked_send_time > current_round_trip_end_) {
round_trip_count_++;
current_round_trip_end_ = last_send_time_;
return true;
}
return false;
}
bool BbrNetworkController::UpdateMinRtt(Timestamp ack_time,
Timestamp last_packet_send_time) {
// Note: This sample does not account for delayed acknowledgement time. This
// means that the RTT measurements here can be artificially high, especially
// on low bandwidth connections.
TimeDelta sample_rtt = ack_time - last_packet_send_time;
last_rtt_ = sample_rtt;
min_rtt_since_last_probe_rtt_ =
std::min(min_rtt_since_last_probe_rtt_, sample_rtt);
// Do not expire min_rtt if none was ever available.
bool min_rtt_expired =
!min_rtt_.IsZero() && (ack_time > (min_rtt_timestamp_ + kMinRttExpiry));
if (min_rtt_expired || sample_rtt < min_rtt_ || min_rtt_.IsZero()) {
RTC_LOG(LS_INFO) << "Min RTT updated, old value: " << ToString(min_rtt_)
<< ", new value: " << ToString(sample_rtt)
<< ", current time: " << ToString(ack_time);
if (ShouldExtendMinRttExpiry()) {
min_rtt_expired = false;
} else {
min_rtt_ = sample_rtt;
}
min_rtt_timestamp_ = ack_time;
// Reset since_last_probe_rtt fields.
min_rtt_since_last_probe_rtt_ = TimeDelta::PlusInfinity();
app_limited_since_last_probe_rtt_ = false;
}
return min_rtt_expired;
}
void BbrNetworkController::UpdateBandwidth(
Timestamp ack_time,
const std::vector<PacketResult>& acked_packets) {
// There are two possible maximum receive bandwidths based on the duration
// from send to ack of a packet, either including or excluding the time until
// the current ack was received. Therefore looking at the last and the first
// packet is enough. This holds if at most one feedback was received during
// the sending of the acked packets.
std::array<const PacketResult, 2> packets = {
{acked_packets.front(), acked_packets.back()}};
for (const PacketResult& packet : packets) {
const Timestamp& send_time = packet.sent_packet->send_time;
is_app_limited_ = send_time > end_of_app_limited_phase_;
auto result = send_ack_tracker_.GetRatesByAckTime(send_time, ack_time);
if (result.acked_data == DataSize::Zero())
continue;
send_ack_tracker_.ClearOldSamples(send_time);
DataRate ack_rate = result.acked_data / result.ack_timespan;
DataRate send_rate = result.send_timespan.IsZero()
? DataRate::Infinity()
: result.acked_data / result.send_timespan;
DataRate bandwidth = std::min(send_rate, ack_rate);
if (!bandwidth.IsFinite())
continue;
if (!is_app_limited_ || bandwidth > BandwidthEstimate()) {
max_bandwidth_.Update(bandwidth, round_trip_count_);
}
}
}
bool BbrNetworkController::ShouldExtendMinRttExpiry() const {
if (config_.probe_rtt_disabled_if_app_limited &&
app_limited_since_last_probe_rtt_) {
// Extend the current min_rtt if we've been app limited recently.
return true;
}
const bool min_rtt_increased_since_last_probe =
min_rtt_since_last_probe_rtt_ > min_rtt_ * kSimilarMinRttThreshold;
if (config_.probe_rtt_skipped_if_similar_rtt &&
app_limited_since_last_probe_rtt_ &&
!min_rtt_increased_since_last_probe) {
// Extend the current min_rtt if we've been app limited recently and an rtt
// has been measured in that time that's less than 12.5% more than the
// current min_rtt.
return true;
}
return false;
}
void BbrNetworkController::UpdateGainCyclePhase(Timestamp now,
DataSize prior_in_flight,
bool has_losses) {
// In most cases, the cycle is advanced after an RTT passes.
bool should_advance_gain_cycling = now - last_cycle_start_ > GetMinRtt();
// If the pacing gain is above 1.0, the connection is trying to probe the
// bandwidth by increasing the number of bytes in flight to at least
// pacing_gain * BDP. Make sure that it actually reaches the target, as long
// as there are no losses suggesting that the buffers are not able to hold
// that much.
if (pacing_gain_ > 1.0 && !has_losses &&
prior_in_flight < GetTargetCongestionWindow(pacing_gain_)) {
should_advance_gain_cycling = false;
}
// If pacing gain is below 1.0, the connection is trying to drain the extra
// queue which could have been incurred by probing prior to it. If the number
// of bytes in flight falls down to the estimated BDP value earlier, conclude
// that the queue has been successfully drained and exit this cycle early.
if (pacing_gain_ < 1.0 && prior_in_flight <= GetTargetCongestionWindow(1)) {
should_advance_gain_cycling = true;
}
if (should_advance_gain_cycling) {
cycle_current_offset_ = (cycle_current_offset_ + 1) % kGainCycleLength;
last_cycle_start_ = now;
// Stay in low gain mode until the target BDP is hit.
// Low gain mode will be exited immediately when the target BDP is achieved.
if (config_.fully_drain_queue && pacing_gain_ < 1 &&
GetPacingGain(cycle_current_offset_) == 1 &&
prior_in_flight > GetTargetCongestionWindow(1)) {
return;
}
pacing_gain_ = GetPacingGain(cycle_current_offset_);
}
}
void BbrNetworkController::CheckIfFullBandwidthReached() {
if (last_sample_is_app_limited_) {
return;
}
DataRate target = bandwidth_at_last_round_ * kStartupGrowthTarget;
if (BandwidthEstimate() >= target) {
bandwidth_at_last_round_ = BandwidthEstimate();
rounds_without_bandwidth_gain_ = 0;
return;
}
rounds_without_bandwidth_gain_++;
if ((rounds_without_bandwidth_gain_ >= config_.num_startup_rtts) ||
(exit_startup_on_loss_ && InRecovery())) {
is_at_full_bandwidth_ = true;
}
}
void BbrNetworkController::MaybeExitStartupOrDrain(
const TransportPacketsFeedback& msg) {
int64_t exit_threshold_ms = config_.exit_startup_rtt_threshold_ms;
bool rtt_over_threshold =
exit_threshold_ms > 0 && (last_rtt_ - min_rtt_).ms() > exit_threshold_ms;
if (mode_ == STARTUP && (is_at_full_bandwidth_ || rtt_over_threshold)) {
if (rtt_over_threshold)
RTC_LOG(LS_INFO) << "Exiting startup due to rtt increase from: "
<< ToString(min_rtt_) << " to:" << ToString(last_rtt_)
<< " > "
<< ToString(min_rtt_ + TimeDelta::ms(exit_threshold_ms));
mode_ = DRAIN;
pacing_gain_ = kDrainGain;
congestion_window_gain_ = kHighGain;
}
if (mode_ == DRAIN && msg.data_in_flight <= GetTargetCongestionWindow(1)) {
EnterProbeBandwidthMode(msg.feedback_time);
}
}
void BbrNetworkController::MaybeEnterOrExitProbeRtt(
const TransportPacketsFeedback& msg,
bool is_round_start,
bool min_rtt_expired) {
if (min_rtt_expired && mode_ != PROBE_RTT) {
mode_ = PROBE_RTT;
pacing_gain_ = 1;
// Do not decide on the time to exit PROBE_RTT until the |bytes_in_flight|
// is at the target small value.
exit_probe_rtt_at_ = Timestamp();
RTC_LOG(LS_INFO) << "Entering RTT Probe";
}
if (mode_ == PROBE_RTT) {
is_app_limited_ = true;
end_of_app_limited_phase_ = last_send_time_;
if (!exit_probe_rtt_at_.IsInitialized()) {
// If the window has reached the appropriate size, schedule exiting
// PROBE_RTT. The CWND during PROBE_RTT is kMinimumCongestionWindow, but
// we allow an extra packet since QUIC checks CWND before sending a
// packet.
if (msg.data_in_flight < ProbeRttCongestionWindow() + kMaxPacketSize) {
exit_probe_rtt_at_ = msg.feedback_time + kProbeRttTime;
probe_rtt_round_passed_ = false;
}
} else {
if (is_round_start) {
probe_rtt_round_passed_ = true;
}
if (msg.feedback_time >= exit_probe_rtt_at_ && probe_rtt_round_passed_) {
min_rtt_timestamp_ = msg.feedback_time;
RTC_LOG(LS_INFO) << "Exiting RTT Probe";
if (!is_at_full_bandwidth_) {
EnterStartupMode();
} else {
EnterProbeBandwidthMode(msg.feedback_time);
}
}
}
}
}
void BbrNetworkController::UpdateRecoveryState(Timestamp last_acked_send_time,
bool has_losses,
bool is_round_start) {
// Exit recovery when there are no losses for a round.
if (has_losses) {
end_recovery_at_ = last_acked_send_time;
}
switch (recovery_state_) {
case NOT_IN_RECOVERY:
// Enter conservation on the first loss.
if (has_losses) {
recovery_state_ = CONSERVATION;
if (mode_ == STARTUP) {
recovery_state_ = config_.initial_conservation_in_startup;
}
// This will cause the |recovery_window_| to be set to the correct
// value in CalculateRecoveryWindow().
recovery_window_ = DataSize::Zero();
// Since the conservation phase is meant to be lasting for a whole
// round, extend the current round as if it were started right now.
current_round_trip_end_ = last_send_time_;
}
break;
case CONSERVATION:
case MEDIUM_GROWTH:
if (is_round_start) {
recovery_state_ = GROWTH;
}
RTC_FALLTHROUGH();
case GROWTH:
// Exit recovery if appropriate.
if (!has_losses && last_acked_send_time > end_recovery_at_) {
recovery_state_ = NOT_IN_RECOVERY;
}
break;
}
}
void BbrNetworkController::UpdateAckAggregationBytes(
Timestamp ack_time,
DataSize newly_acked_bytes) {
// Compute how many bytes are expected to be delivered, assuming max bandwidth
// is correct.
DataSize expected_bytes_acked =
max_bandwidth_.GetBest() * (ack_time - aggregation_epoch_start_time_);
// Reset the current aggregation epoch as soon as the ack arrival rate is less
// than or equal to the max bandwidth.
if (aggregation_epoch_bytes_ <= expected_bytes_acked) {
// Reset to start measuring a new aggregation epoch.
aggregation_epoch_bytes_ = newly_acked_bytes;
aggregation_epoch_start_time_ = ack_time;
return;
}
// Compute how many extra bytes were delivered vs max bandwidth.
// Include the bytes most recently acknowledged to account for stretch acks.
aggregation_epoch_bytes_ += newly_acked_bytes;
max_ack_height_.Update(aggregation_epoch_bytes_ - expected_bytes_acked,
round_trip_count_);
}
void BbrNetworkController::CalculatePacingRate() {
if (BandwidthEstimate().IsZero()) {
return;
}
DataRate target_rate = pacing_gain_ * BandwidthEstimate();
if (config_.rate_based_recovery && InRecovery()) {
pacing_rate_ = pacing_gain_ * max_bandwidth_.GetThirdBest();
}
if (is_at_full_bandwidth_) {
pacing_rate_ = target_rate;
return;
}
// Pace at the rate of initial_window / RTT as soon as RTT measurements are
// available.
if (pacing_rate_.IsZero() && !rtt_stats_.min_rtt().IsZero()) {
pacing_rate_ = initial_congestion_window_ / rtt_stats_.min_rtt();
return;
}
// Slow the pacing rate in STARTUP once loss has ever been detected.
const bool has_ever_detected_loss = end_recovery_at_.IsInitialized();
if (config_.slower_startup && has_ever_detected_loss) {
pacing_rate_ = kStartupAfterLossGain * BandwidthEstimate();
return;
}
// Do not decrease the pacing rate during the startup.
pacing_rate_ = std::max(pacing_rate_, target_rate);
}
void BbrNetworkController::CalculateCongestionWindow(DataSize bytes_acked) {
if (mode_ == PROBE_RTT) {
return;
}
DataSize target_window = GetTargetCongestionWindow(congestion_window_gain_);
if (rtt_variance_weight_ > 0.f && !BandwidthEstimate().IsZero()) {
target_window += rtt_variance_weight_ * rtt_stats_.mean_deviation() *
BandwidthEstimate();
} else if (max_aggregation_bytes_multiplier_ > 0 && is_at_full_bandwidth_) {
// Subtracting only half the bytes_acked_since_queue_drained ensures sending
// doesn't completely stop for a long period of time if the queue hasn't
// been drained recently.
if (max_aggregation_bytes_multiplier_ * max_ack_height_.GetBest() >
bytes_acked_since_queue_drained_ / 2) {
target_window +=
max_aggregation_bytes_multiplier_ * max_ack_height_.GetBest() -
bytes_acked_since_queue_drained_ / 2;
}
} else if (is_at_full_bandwidth_) {
target_window += max_ack_height_.GetBest();
}
// Instead of immediately setting the target CWND as the new one, BBR grows
// the CWND towards |target_window| by only increasing it |bytes_acked| at a
// time.
if (is_at_full_bandwidth_) {
congestion_window_ =
std::min(target_window, congestion_window_ + bytes_acked);
} else if (congestion_window_ < target_window ||
total_bytes_acked_ < initial_congestion_window_) {
// If the connection is not yet out of startup phase, do not decrease the
// window.
congestion_window_ = congestion_window_ + bytes_acked;
}
// Enforce the limits on the congestion window.
congestion_window_ = std::max(congestion_window_, kMinimumCongestionWindow);
congestion_window_ = std::min(congestion_window_, max_congestion_window_);
}
void BbrNetworkController::CalculateRecoveryWindow(DataSize bytes_acked,
DataSize bytes_lost,
DataSize bytes_in_flight) {
if (config_.rate_based_recovery ||
(config_.rate_based_startup && mode_ == STARTUP)) {
return;
}
if (recovery_state_ == NOT_IN_RECOVERY) {
return;
}
// Set up the initial recovery window.
if (recovery_window_.IsZero()) {
recovery_window_ = bytes_in_flight + bytes_acked;
recovery_window_ = std::max(kMinimumCongestionWindow, recovery_window_);
return;
}
// Remove losses from the recovery window, while accounting for a potential
// integer underflow.
recovery_window_ = recovery_window_ >= bytes_lost
? recovery_window_ - bytes_lost
: kMaxSegmentSize;
// In CONSERVATION mode, just subtracting losses is sufficient. In GROWTH,
// release additional |bytes_acked| to achieve a slow-start-like behavior.
// In MEDIUM_GROWTH, release |bytes_acked| / 2 to split the difference.
if (recovery_state_ == GROWTH) {
recovery_window_ += bytes_acked;
} else if (recovery_state_ == MEDIUM_GROWTH) {
recovery_window_ += bytes_acked / 2;
}
// Sanity checks. Ensure that we always allow to send at leastś
// |bytes_acked| in response.
recovery_window_ = std::max(recovery_window_, bytes_in_flight + bytes_acked);
recovery_window_ = std::max(kMinimumCongestionWindow, recovery_window_);
}
void BbrNetworkController::OnApplicationLimited(DataSize bytes_in_flight) {
if (bytes_in_flight >= GetCongestionWindow()) {
return;
}
app_limited_since_last_probe_rtt_ = true;
is_app_limited_ = true;
end_of_app_limited_phase_ = last_send_time_;
RTC_LOG(LS_INFO) << "Becoming application limited. Last sent time: "
<< ToString(last_send_time_)
<< ", CWND: " << ToString(GetCongestionWindow());
}
} // namespace bbr
} // namespace webrtc

407
modules/congestion_controller/bbr/bbr_network_controller.h Normal file
View File

@ -0,0 +1,407 @@
/*
* Copyright (c) 2018 The WebRTC project authors. All Rights Reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
// BBR (Bottleneck Bandwidth and RTT) congestion control algorithm.
// Based on the Quic BBR implementation in Chromium.
#ifndef MODULES_CONGESTION_CONTROLLER_BBR_BBR_NETWORK_CONTROLLER_H_
#define MODULES_CONGESTION_CONTROLLER_BBR_BBR_NETWORK_CONTROLLER_H_
#include <cstdint>
#include <string>
#include <vector>
#include "modules/congestion_controller/bbr/data_transfer_tracker.h"
#include "modules/congestion_controller/bbr/rtt_stats.h"
#include "modules/congestion_controller/bbr/windowed_filter.h"
#include "modules/congestion_controller/network_control/include/network_control.h"
#include "modules/congestion_controller/network_control/include/network_types.h"
#include "modules/congestion_controller/network_control/include/network_units.h"
#include "api/optional.h"
#include "rtc_base/random.h"
namespace webrtc {
namespace bbr {
typedef int64_t BbrPacketCount;
typedef int64_t BbrRoundTripCount;
// BbrSender implements BBR congestion control algorithm. BBR aims to estimate
// the current available Bottleneck Bandwidth and RTT (hence the name), and
// regulates the pacing rate and the size of the congestion window based on
// those signals.
//
// BBR relies on pacing in order to function properly. Do not use BBR when
// pacing is disabled.
class BbrNetworkController : public NetworkControllerInterface {
public:
enum Mode {
// Startup phase of the connection.
STARTUP,
// After achieving the highest possible bandwidth during the startup, lower
// the pacing rate in order to drain the queue.
DRAIN,
// Cruising mode.
PROBE_BW,
// Temporarily slow down sending in order to empty the buffer and measure
// the real minimum RTT.
PROBE_RTT,
};
// Indicates how the congestion control limits the amount of bytes in flight.
enum RecoveryState {
// Do not limit.
NOT_IN_RECOVERY,
// Allow an extra outstanding byte for each byte acknowledged.
CONSERVATION,
// Allow 1.5 extra outstanding bytes for each byte acknowledged.
MEDIUM_GROWTH,
// Allow two extra outstanding bytes for each byte acknowledged (slow
// start).
GROWTH
};
// Debug state can be exported in order to troubleshoot potential congestion
// control issues.
struct DebugState {
explicit DebugState(const BbrNetworkController& sender);
DebugState(const DebugState& state);
Mode mode;
DataRate max_bandwidth;
BbrRoundTripCount round_trip_count;
int gain_cycle_index;
DataSize congestion_window;
bool is_at_full_bandwidth;
DataRate bandwidth_at_last_round;
BbrRoundTripCount rounds_without_bandwidth_gain;
TimeDelta min_rtt;
Timestamp min_rtt_timestamp;
RecoveryState recovery_state;
DataSize recovery_window;
bool last_sample_is_app_limited;
Timestamp end_of_app_limited_phase;
};
BbrNetworkController(NetworkControllerObserver* observer,
NetworkControllerConfig config);
~BbrNetworkController() override;
// NetworkControllerInterface
void OnNetworkAvailability(NetworkAvailability msg) override;
void OnNetworkRouteChange(NetworkRouteChange msg) override;
void OnProcessInterval(ProcessInterval msg) override;
void OnSentPacket(SentPacket msg) override;
void OnStreamsConfig(StreamsConfig msg) override;
void OnTargetRateConstraints(TargetRateConstraints msg) override;
void OnTransportPacketsFeedback(TransportPacketsFeedback msg) override;
// Part of remote bitrate estimation api, not implemented for BBR
void OnRemoteBitrateReport(RemoteBitrateReport msg) override;
void OnRoundTripTimeUpdate(RoundTripTimeUpdate msg) override;
void OnTransportLossReport(TransportLossReport msg) override;
private:
struct BbrControllerConfig {
// Default config based on default QUIC config
static BbrControllerConfig DefaultConfig();
double probe_bw_pacing_gain_offset;
double encoder_rate_gain;
double encoder_rate_gain_in_probe_rtt;
// RTT delta to determine if startup should be exited due to increased RTT.
int64_t exit_startup_rtt_threshold_ms;
double probe_rtt_congestion_window_gain;
// Configurable in QUIC BBR:
bool exit_startup_on_loss;
// The number of RTTs to stay in STARTUP mode. Defaults to 3.
BbrRoundTripCount num_startup_rtts;
// When true, recovery is rate based rather than congestion window based.
bool rate_based_recovery;
double max_aggregation_bytes_multiplier;
// When true, pace at 1.5x and disable packet conservation in STARTUP.
bool slower_startup;
// When true, disables packet conservation in STARTUP.
bool rate_based_startup;
// If true, will not exit low gain mode until bytes_in_flight drops below
// BDP or it's time for high gain mode.
bool fully_drain_queue;
// Used as the initial packet conservation mode when first entering
// recovery.
RecoveryState initial_conservation_in_startup;
double max_ack_height_window_multiplier;
// If true, use a CWND of 0.75*BDP during probe_rtt instead of 4 packets.
bool probe_rtt_based_on_bdp;
// If true, skip probe_rtt and update the timestamp of the existing min_rtt
// to now if min_rtt over the last cycle is within 12.5% of the current
// min_rtt. Even if the min_rtt is 12.5% too low, the 25% gain cycling and
// 2x CWND gain should overcome an overly small min_rtt.
bool probe_rtt_skipped_if_similar_rtt;
// If true, disable PROBE_RTT entirely as long as the connection was
// recently app limited.
bool probe_rtt_disabled_if_app_limited;
};
// Containing values that when changed should trigger an update.
struct UpdateState {
Mode mode = Mode::STARTUP;
DataRate bandwidth;
TimeDelta rtt;
DataRate pacing_rate;
DataRate target_rate;
bool probing_for_bandwidth = false;
};
void Reset();
void SignalUpdatedRates(Timestamp at_time);
bool InSlowStart() const;
bool InRecovery() const;
bool IsProbingForMoreBandwidth() const;
bool CanSend(DataSize bytes_in_flight);
DataRate PacingRate() const;
DataRate BandwidthEstimate() const;
DataSize GetCongestionWindow() const;
double GetPacingGain(int round_offset) const;
void OnApplicationLimited(DataSize bytes_in_flight);
// End implementation of SendAlgorithmInterface.
typedef WindowedFilter<DataRate,
MaxFilter<DataRate>,
BbrRoundTripCount,
BbrRoundTripCount>
MaxBandwidthFilter;
typedef WindowedFilter<TimeDelta,
MaxFilter<TimeDelta>,
BbrRoundTripCount,
BbrRoundTripCount>
MaxAckDelayFilter;
typedef WindowedFilter<DataSize,
MaxFilter<DataSize>,
BbrRoundTripCount,
BbrRoundTripCount>
MaxAckHeightFilter;
// Returns the current estimate of the RTT of the connection. Outside of the
// edge cases, this is minimum RTT.
TimeDelta GetMinRtt() const;
// Computes the target congestion window using the specified gain.
DataSize GetTargetCongestionWindow(double gain) const;
// The target congestion window during PROBE_RTT.
DataSize ProbeRttCongestionWindow() const;
// Returns true if the current min_rtt should be kept and we should not enter
// PROBE_RTT immediately.
bool ShouldExtendMinRttExpiry() const;
// Enters the STARTUP mode.
void EnterStartupMode();
// Enters the PROBE_BW mode.
void EnterProbeBandwidthMode(Timestamp now);
// Updates the round-trip counter if a round-trip has passed. Returns true if
// the counter has been advanced.
bool UpdateRoundTripCounter(Timestamp last_acked_timestamp);
// Updates the current bandwidth and min_rtt estimate based on the samples for
// the received acknowledgements. Returns true if min_rtt has expired.
void UpdateBandwidth(Timestamp now,
const std::vector<PacketResult>& acked_packets);
bool UpdateMinRtt(Timestamp ack_time, Timestamp last_packet_send_time);
// Updates the current gain used in PROBE_BW mode.
void UpdateGainCyclePhase(Timestamp now,
DataSize prior_in_flight,
bool has_losses);
// Tracks for how many round-trips the bandwidth has not increased
// significantly.
void CheckIfFullBandwidthReached();
// Transitions from STARTUP to DRAIN and from DRAIN to PROBE_BW if
// appropriate.
void MaybeExitStartupOrDrain(const TransportPacketsFeedback&);
// Decides whether to enter or exit PROBE_RTT.
void MaybeEnterOrExitProbeRtt(const TransportPacketsFeedback& msg,
bool is_round_start,
bool min_rtt_expired);
// Determines whether BBR needs to enter, exit or advance state of the
// recovery.
void UpdateRecoveryState(Timestamp last_acked_send_time,
bool has_losses,
bool is_round_start);
// Updates the ack aggregation max filter in bytes.
void UpdateAckAggregationBytes(Timestamp ack_time,
DataSize newly_acked_bytes);
// Determines the appropriate pacing rate for the connection.
void CalculatePacingRate();
// Determines the appropriate congestion window for the connection.
void CalculateCongestionWindow(DataSize bytes_acked);
// Determines the approriate wQuicPacketNumberindow that constrains the
// in-flight during recovery.
void CalculateRecoveryWindow(DataSize bytes_acked,
DataSize bytes_lost,
DataSize bytes_in_flight);
NetworkControllerObserver* observer_;
RttStats rtt_stats_;
webrtc::Random random_;
DataTransferTracker send_ack_tracker_;
rtc::Optional<TargetRateConstraints> constraints_;
Mode mode_ = STARTUP;
BbrControllerConfig config_;
// The total number of congestion controlled bytes which were acknowledged.
DataSize total_bytes_acked_;
// The total number of congestion controlled bytes sent during the connection.
DataSize total_bytes_sent_;
// The time at which the last acknowledged packet was sent. Set to
// Timestamp::ms(0) if no valid timestamp is available.
Timestamp last_acked_packet_sent_time_ = Timestamp::ms(0);
// The time at which the most recent packet was acknowledged.
Timestamp last_acked_packet_ack_time_ = Timestamp::ms(0);
bool is_app_limited_ = false;
// The packet that will be acknowledged after this one will cause the sampler
// to exit the app-limited phase.
Timestamp end_of_app_limited_phase_ = Timestamp::ms(0);
// The number of the round trips that have occurred during the connection.
BbrRoundTripCount round_trip_count_ = 0;
// The send time of the most recently sent packet.
Timestamp last_send_time_ = Timestamp::ms(0);
// Acknowledgement of any packet after |current_round_trip_end_| will cause
// the round trip counter to advance.
Timestamp current_round_trip_end_ = Timestamp::ms(0);
// The filter that tracks the maximum bandwidth over the multiple recent
// round-trips.
MaxBandwidthFilter max_bandwidth_;
DataRate default_bandwidth_;
// Tracks the maximum number of bytes acked faster than the sending rate.
MaxAckHeightFilter max_ack_height_;
// The time this aggregation started and the number of bytes acked during it.
Timestamp aggregation_epoch_start_time_;
DataSize aggregation_epoch_bytes_;
// The number of bytes acknowledged since the last time bytes in flight
// dropped below the target window.
DataSize bytes_acked_since_queue_drained_;
// The muliplier for calculating the max amount of extra CWND to add to
// compensate for ack aggregation.
double max_aggregation_bytes_multiplier_ = 0;
// Minimum RTT estimate. Automatically expires within 10 seconds (and
// triggers PROBE_RTT mode) if no new value is sampled during that period.
TimeDelta min_rtt_ = TimeDelta::Zero();
TimeDelta last_rtt_ = TimeDelta::Zero();
// The time at which the current value of |min_rtt_| was assigned.
Timestamp min_rtt_timestamp_ = Timestamp::ms(0);
// The maximum allowed number of bytes in flight.
DataSize congestion_window_;
// The initial value of the |congestion_window_|.
DataSize initial_congestion_window_;
// The largest value the |congestion_window_| can achieve.
DataSize max_congestion_window_;
// The current pacing rate of the connection.
DataRate pacing_rate_ = DataRate::Zero();
// The gain currently applied to the pacing rate.
double pacing_gain_ = 1;
// The gain currently applied to the congestion window.
double congestion_window_gain_ = 1;
// The gain used for the congestion window during PROBE_BW. Latched from
// quic_bbr_cwnd_gain flag.
const double congestion_window_gain_constant_;
// The coefficient by which mean RTT variance is added to the congestion
// window. Latched from quic_bbr_rtt_variation_weight flag.
const double rtt_variance_weight_;
// If true, exit startup if 1RTT has passed with no bandwidth increase and
// the connection is in recovery.
bool exit_startup_on_loss_ = false;
// Number of round-trips in PROBE_BW mode, used for determining the current
// pacing gain cycle.
int cycle_current_offset_ = 0;
// The time at which the last pacing gain cycle was started.
Timestamp last_cycle_start_;
// Indicates whether the connection has reached the full bandwidth mode.
bool is_at_full_bandwidth_ = false;
// Number of rounds during which there was no significant bandwidth increase.
BbrRoundTripCount rounds_without_bandwidth_gain_ = 0;
// The bandwidth compared to which the increase is measured.
DataRate bandwidth_at_last_round_ = DataRate::Zero();
// Time at which PROBE_RTT has to be exited. Setting it to zero indicates
// that the time is yet unknown as the number of packets in flight has not
// reached the required value.
Timestamp exit_probe_rtt_at_;
// Indicates whether a round-trip has passed since PROBE_RTT became active.
bool probe_rtt_round_passed_ = false;
// Indicates whether the most recent bandwidth sample was marked as
// app-limited.
bool last_sample_is_app_limited_ = false;
// Current state of recovery.
RecoveryState recovery_state_ = NOT_IN_RECOVERY;
// Receiving acknowledgement of a packet after |end_recovery_at_| will cause
// BBR to exit the recovery mode. A value after epoch indicates at least one
// loss has been detected, so it must not be set back to epoch.
Timestamp end_recovery_at_ = Timestamp::ms(0);
// A window used to limit the number of bytes in flight during loss recovery.
DataSize recovery_window_;
bool app_limited_since_last_probe_rtt_ = false;
TimeDelta min_rtt_since_last_probe_rtt_ = TimeDelta::PlusInfinity();
UpdateState last_update_state_;
RTC_DISALLOW_COPY_AND_ASSIGN(BbrNetworkController);
};
// Used in log output
std::ostream& operator<<( // no-presubmit-check TODO(webrtc:8982)
std::ostream& os, // no-presubmit-check TODO(webrtc:8982)
const BbrNetworkController::Mode& mode);
} // namespace bbr
} // namespace webrtc
#endif // MODULES_CONGESTION_CONTROLLER_BBR_BBR_NETWORK_CONTROLLER_H_

148
modules/congestion_controller/bbr/bbr_network_controller_unittest.cc Normal file
View File

@ -0,0 +1,148 @@
/*
* Copyright (c) 2018 The WebRTC project authors. All Rights Reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#include <algorithm>
#include <memory>
#include "modules/congestion_controller/bbr/bbr_factory.h"
#include "modules/congestion_controller/bbr/bbr_network_controller.h"
#include "modules/congestion_controller/network_control/test/mock_network_control.h"
#include "modules/congestion_controller/network_control/test/network_control_tester.h"
#include "test/gtest.h"
using testing::Field;
using testing::Matcher;
using testing::AllOf;
using testing::Ge;
using testing::Le;
using testing::NiceMock;
using testing::Property;
using testing::StrictMock;
using testing::_;
namespace webrtc {
namespace bbr {
namespace test {
namespace {
const DataRate kInitialBitrate = DataRate::kbps(60);
const Timestamp kDefaultStartTime = Timestamp::ms(10000000);
constexpr double kDataRateMargin = 0.3;
constexpr double kMinDataRateFactor = 1 - kDataRateMargin;
constexpr double kMaxDataRateFactor = 1 + kDataRateMargin;
inline Matcher<TargetTransferRate> TargetRateCloseTo(DataRate rate) {
DataRate min_data_rate = rate * kMinDataRateFactor;
DataRate max_data_rate = rate * kMaxDataRateFactor;
return Field(&TargetTransferRate::target_rate,
AllOf(Ge(min_data_rate), Le(max_data_rate)));
}
NetworkControllerConfig InitialConfig(
int starting_bandwidth_kbps = kInitialBitrate.kbps(),
int min_data_rate_kbps = 0,
int max_data_rate_kbps = 5 * kInitialBitrate.kbps()) {
NetworkControllerConfig config;
config.constraints.at_time = kDefaultStartTime;
config.constraints.min_data_rate = DataRate::kbps(min_data_rate_kbps);
config.constraints.max_data_rate = DataRate::kbps(max_data_rate_kbps);
config.starting_bandwidth = DataRate::kbps(starting_bandwidth_kbps);
return config;
}
NetworkRouteChange CreateRouteChange(Timestamp at_time,
DataRate start_rate,
DataRate min_rate = DataRate::Zero(),
DataRate max_rate = DataRate::Infinity()) {
NetworkRouteChange route_change;
route_change.at_time = at_time;
route_change.constraints.at_time = at_time;
route_change.constraints.min_data_rate = min_rate;
route_change.constraints.max_data_rate = max_rate;
route_change.starting_rate = start_rate;
return route_change;
}
} // namespace
class BbrNetworkControllerTest : public ::testing::Test {
protected:
BbrNetworkControllerTest() {}
~BbrNetworkControllerTest() override {}
};
TEST_F(BbrNetworkControllerTest, SendsConfigurationOnInitialization) {
StrictMock<webrtc::test::MockNetworkControllerObserver> observer;
EXPECT_CALL(observer,
OnTargetTransferRate(TargetRateCloseTo(kInitialBitrate)));
EXPECT_CALL(observer, OnPacerConfig(Property(&PacerConfig::data_rate,
Ge(kInitialBitrate))));
EXPECT_CALL(observer,
OnCongestionWindow(Field(&CongestionWindow::data_window,
Property(&DataSize::IsFinite, true))));
std::unique_ptr<NetworkControllerInterface> controller_;
controller_.reset(new BbrNetworkController(&observer, InitialConfig()));
testing::Mock::VerifyAndClearExpectations(&observer);
}
TEST_F(BbrNetworkControllerTest, SendsConfigurationOnNetworkRouteChanged) {
StrictMock<webrtc::test::MockNetworkControllerObserver> observer;
EXPECT_CALL(observer, OnTargetTransferRate(_));
EXPECT_CALL(observer, OnPacerConfig(_));
EXPECT_CALL(observer, OnCongestionWindow(_));
std::unique_ptr<NetworkControllerInterface> controller_;
controller_.reset(new BbrNetworkController(&observer, InitialConfig()));
DataRate new_bitrate = DataRate::bps(200000);
EXPECT_CALL(observer, OnTargetTransferRate(TargetRateCloseTo(new_bitrate)));
EXPECT_CALL(observer, OnPacerConfig(Property(&PacerConfig::data_rate,
Ge(kInitialBitrate))));
EXPECT_CALL(observer, OnCongestionWindow(_));
controller_->OnNetworkRouteChange(
CreateRouteChange(kDefaultStartTime, new_bitrate));
testing::Mock::VerifyAndClearExpectations(&observer);
}
// Bandwidth estimation is updated when feedbacks are received.
// Feedbacks which show an increasing delay cause the estimation to be reduced.
TEST_F(BbrNetworkControllerTest, UpdatesTargetSendRate) {
BbrNetworkControllerFactory factory;
webrtc::test::NetworkControllerTester tester(&factory,
InitialConfig(60, 0, 600));
auto packet_producer = &webrtc::test::SimpleTargetRateProducer::ProduceNext;
tester.RunSimulation(TimeDelta::seconds(5), TimeDelta::ms(10),
DataRate::kbps(300), TimeDelta::ms(100),
packet_producer);
EXPECT_GE(tester.GetState().target_rate->target_rate,
DataRate::kbps(300) * kMinDataRateFactor);
EXPECT_LE(tester.GetState().target_rate->target_rate,
DataRate::kbps(300) * kMaxDataRateFactor);
tester.RunSimulation(TimeDelta::seconds(30), TimeDelta::ms(10),
DataRate::kbps(500), TimeDelta::ms(100),
packet_producer);
EXPECT_GE(tester.GetState().target_rate->target_rate,
DataRate::kbps(500) * kMinDataRateFactor);
EXPECT_LE(tester.GetState().target_rate->target_rate,
DataRate::kbps(500) * kMaxDataRateFactor);
tester.RunSimulation(TimeDelta::seconds(30), TimeDelta::ms(10),
DataRate::kbps(100), TimeDelta::ms(200),
packet_producer);
EXPECT_GE(tester.GetState().target_rate->target_rate,
DataRate::kbps(100) * kMinDataRateFactor);
EXPECT_LE(tester.GetState().target_rate->target_rate,
DataRate::kbps(100) * kMaxDataRateFactor);
}
} // namespace test
} // namespace bbr
} // namespace webrtc

25
modules/congestion_controller/network_control/test/network_control_tester.cc
View File

@ -57,7 +57,7 @@ SentPacket SimpleTargetRateProducer::ProduceNext(
return packet;
}
FeedbackBasedNetworkControllerTester::FeedbackBasedNetworkControllerTester(
NetworkControllerTester::NetworkControllerTester(
NetworkControllerFactoryInterface* factory,
NetworkControllerConfig initial_config)
: current_time_(Timestamp::seconds(100000)),
@ -67,14 +67,12 @@ FeedbackBasedNetworkControllerTester::FeedbackBasedNetworkControllerTester(
process_interval_ = factory->GetProcessInterval();
}
FeedbackBasedNetworkControllerTester::~FeedbackBasedNetworkControllerTester() =
default;
NetworkControllerTester::~NetworkControllerTester() = default;
PacketResult FeedbackBasedNetworkControllerTester::SimulateSend(
SentPacket packet,
TimeDelta time_delta,
TimeDelta propagation_delay,
DataRate actual_bandwidth) {
PacketResult NetworkControllerTester::SimulateSend(SentPacket packet,
TimeDelta time_delta,
TimeDelta propagation_delay,
DataRate actual_bandwidth) {
TimeDelta bandwidth_delay = packet.size / actual_bandwidth;
accumulated_delay_ =
std::max(accumulated_delay_ - time_delta, TimeDelta::Zero());
@ -87,12 +85,11 @@ PacketResult FeedbackBasedNetworkControllerTester::SimulateSend(
return result;
}
void FeedbackBasedNetworkControllerTester::RunSimulation(
TimeDelta duration,
TimeDelta packet_interval,
DataRate actual_bandwidth,
TimeDelta propagation_delay,
PacketProducer next_packet) {
void NetworkControllerTester::RunSimulation(TimeDelta duration,
TimeDelta packet_interval,
DataRate actual_bandwidth,
TimeDelta propagation_delay,
PacketProducer next_packet) {
Timestamp start_time = current_time_;
Timestamp last_process_time = current_time_;
while (current_time_ - start_time < duration) {

9
modules/congestion_controller/network_control/test/network_control_tester.h
View File

@ -51,7 +51,7 @@ class NetworkControlCacher : public NetworkControllerObserver {
NetworkControlState current_state_;
};
class FeedbackBasedNetworkControllerTester {
class NetworkControllerTester {
public:
// A PacketProducer is a function that takes a network control state, a
// timestamp representing the expected send time and a time delta of the send
@ -59,10 +59,9 @@ class FeedbackBasedNetworkControllerTester {
// SentPacket struct with actual send time and packet size.
using PacketProducer = std::function<
SentPacket(const NetworkControlState&, Timestamp, TimeDelta)>;
FeedbackBasedNetworkControllerTester(
NetworkControllerFactoryInterface* factory,
NetworkControllerConfig initial_config);
~FeedbackBasedNetworkControllerTester();
NetworkControllerTester(NetworkControllerFactoryInterface* factory,
NetworkControllerConfig initial_config);
~NetworkControllerTester();
// Runs the simulations for the given duration, the PacketProducer will be
// called repeatedly based on the given packet interval and the network will