blob: 0c1e23f9eea4a6580e45d2d05b46e3e58f2dc5f1 [file] [log] [blame]
/*
* Copyright (c) 2016 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/probe_bitrate_estimator.h"
#include <algorithm>
#include "logging/rtc_event_log/events/rtc_event_probe_result_failure.h"
#include "logging/rtc_event_log/events/rtc_event_probe_result_success.h"
#include "logging/rtc_event_log/rtc_event_log.h"
#include "rtc_base/checks.h"
#include "rtc_base/logging.h"
#include "rtc_base/ptr_util.h"
namespace {
// The minumum number of probes we need to receive feedback about in percent
// in order to have a valid estimate.
constexpr int kMinReceivedProbesPercent = 80;
// The minumum number of bytes we need to receive feedback about in percent
// in order to have a valid estimate.
constexpr int kMinReceivedBytesPercent = 80;
// The maximum |receive rate| / |send rate| ratio for a valid estimate.
constexpr float kMaxValidRatio = 2.0f;
// The minimum |receive rate| / |send rate| ratio assuming that the link is
// not saturated, i.e. we assume that we will receive at least
// kMinRatioForUnsaturatedLink * |send rate| if |send rate| is less than the
// link capacity.
constexpr float kMinRatioForUnsaturatedLink = 0.9f;
// The target utilization of the link. If we know true link capacity
// we'd like to send at 95% of that rate.
constexpr float kTargetUtilizationFraction = 0.95f;
// The maximum time period over which the cluster history is retained.
// This is also the maximum time period beyond which a probing burst is not
// expected to last.
constexpr int kMaxClusterHistoryMs = 1000;
// The maximum time interval between first and the last probe on a cluster
// on the sender side as well as the receive side.
constexpr int kMaxProbeIntervalMs = 1000;
} // namespace
namespace webrtc {
ProbeBitrateEstimator::ProbeBitrateEstimator(RtcEventLog* event_log)
: event_log_(event_log) {}
ProbeBitrateEstimator::~ProbeBitrateEstimator() = default;
int ProbeBitrateEstimator::HandleProbeAndEstimateBitrate(
const PacketFeedback& packet_feedback) {
int cluster_id = packet_feedback.pacing_info.probe_cluster_id;
RTC_DCHECK_NE(cluster_id, PacedPacketInfo::kNotAProbe);
EraseOldClusters(packet_feedback.arrival_time_ms - kMaxClusterHistoryMs);
int payload_size_bits = packet_feedback.payload_size * 8;
AggregatedCluster* cluster = &clusters_[cluster_id];
if (packet_feedback.send_time_ms < cluster->first_send_ms) {
cluster->first_send_ms = packet_feedback.send_time_ms;
}
if (packet_feedback.send_time_ms > cluster->last_send_ms) {
cluster->last_send_ms = packet_feedback.send_time_ms;
cluster->size_last_send = payload_size_bits;
}
if (packet_feedback.arrival_time_ms < cluster->first_receive_ms) {
cluster->first_receive_ms = packet_feedback.arrival_time_ms;
cluster->size_first_receive = payload_size_bits;
}
if (packet_feedback.arrival_time_ms > cluster->last_receive_ms) {
cluster->last_receive_ms = packet_feedback.arrival_time_ms;
}
cluster->size_total += payload_size_bits;
cluster->num_probes += 1;
RTC_DCHECK_GT(packet_feedback.pacing_info.probe_cluster_min_probes, 0);
RTC_DCHECK_GT(packet_feedback.pacing_info.probe_cluster_min_bytes, 0);
int min_probes = packet_feedback.pacing_info.probe_cluster_min_probes *
kMinReceivedProbesPercent / 100;
int min_bytes = packet_feedback.pacing_info.probe_cluster_min_bytes *
kMinReceivedBytesPercent / 100;
if (cluster->num_probes < min_probes || cluster->size_total < min_bytes * 8)
return -1;
float send_interval_ms = cluster->last_send_ms - cluster->first_send_ms;
float receive_interval_ms =
cluster->last_receive_ms - cluster->first_receive_ms;
if (send_interval_ms <= 0 || send_interval_ms > kMaxProbeIntervalMs ||
receive_interval_ms <= 0 || receive_interval_ms > kMaxProbeIntervalMs) {
LOG(LS_INFO) << "Probing unsuccessful, invalid send/receive interval"
<< " [cluster id: " << cluster_id
<< "] [send interval: " << send_interval_ms << " ms]"
<< " [receive interval: " << receive_interval_ms << " ms]";
if (event_log_) {
event_log_->Log(rtc::MakeUnique<RtcEventProbeResultFailure>(
cluster_id, ProbeFailureReason::kInvalidSendReceiveInterval));
}
return -1;
}
// Since the |send_interval_ms| does not include the time it takes to actually
// send the last packet the size of the last sent packet should not be
// included when calculating the send bitrate.
RTC_DCHECK_GT(cluster->size_total, cluster->size_last_send);
float send_size = cluster->size_total - cluster->size_last_send;
float send_bps = send_size / send_interval_ms * 1000;
// Since the |receive_interval_ms| does not include the time it takes to
// actually receive the first packet the size of the first received packet
// should not be included when calculating the receive bitrate.
RTC_DCHECK_GT(cluster->size_total, cluster->size_first_receive);
float receive_size = cluster->size_total - cluster->size_first_receive;
float receive_bps = receive_size / receive_interval_ms * 1000;
float ratio = receive_bps / send_bps;
if (ratio > kMaxValidRatio) {
LOG(LS_INFO) << "Probing unsuccessful, receive/send ratio too high"
<< " [cluster id: " << cluster_id << "] [send: " << send_size
<< " bytes / " << send_interval_ms
<< " ms = " << send_bps / 1000 << " kb/s]"
<< " [receive: " << receive_size << " bytes / "
<< receive_interval_ms << " ms = " << receive_bps / 1000
<< " kb/s]"
<< " [ratio: " << receive_bps / 1000 << " / "
<< send_bps / 1000 << " = " << ratio << " > kMaxValidRatio ("
<< kMaxValidRatio << ")]";
if (event_log_) {
event_log_->Log(rtc::MakeUnique<RtcEventProbeResultFailure>(
cluster_id, ProbeFailureReason::kInvalidSendReceiveRatio));
}
return -1;
}
LOG(LS_INFO) << "Probing successful"
<< " [cluster id: " << cluster_id << "] [send: " << send_size
<< " bytes / " << send_interval_ms << " ms = " << send_bps / 1000
<< " kb/s]"
<< " [receive: " << receive_size << " bytes / "
<< receive_interval_ms << " ms = " << receive_bps / 1000
<< " kb/s]";
float res = std::min(send_bps, receive_bps);
// If we're receiving at significantly lower bitrate than we were sending at,
// it suggests that we've found the true capacity of the link. In this case,
// set the target bitrate slightly lower to not immediately overuse.
if (receive_bps < kMinRatioForUnsaturatedLink * send_bps) {
RTC_DCHECK_GT(send_bps, receive_bps);
res = kTargetUtilizationFraction * receive_bps;
}
if (event_log_) {
event_log_->Log(
rtc::MakeUnique<RtcEventProbeResultSuccess>(cluster_id, res));
}
estimated_bitrate_bps_ = rtc::Optional<int>(res);
return *estimated_bitrate_bps_;
}
rtc::Optional<int>
ProbeBitrateEstimator::FetchAndResetLastEstimatedBitrateBps() {
rtc::Optional<int> estimated_bitrate_bps = estimated_bitrate_bps_;
estimated_bitrate_bps_.reset();
return estimated_bitrate_bps;
}
void ProbeBitrateEstimator::EraseOldClusters(int64_t timestamp_ms) {
for (auto it = clusters_.begin(); it != clusters_.end();) {
if (it->second.last_receive_ms < timestamp_ms) {
it = clusters_.erase(it);
} else {
++it;
}
}
}
} // namespace webrtc