mediasoup 3.26.0 → 3.27.1

package/worker/test/src/RTC/BWE/TestAimdRateControl.cpp

@@ -0,0 +1,400 @@
+#include "common.hpp"
+#include "RTC/BWE/AimdRateControl.hpp"
+#include "RTC/BWE/BweTypes.hpp"
+#include <catch2/catch_test_macros.hpp>
+#include <catch2/matchers/catch_matchers_floating_point.hpp>
+#include <cmath>
+
+SCENARIO("BWE AimdRateControl", "[bwe][aimdratecontrol]")
+{
+	constexpr int64_t InitialTimeUs{ 123456 * 1000 };
+	// Fraction of the measured throughput the bitrate is dropped to after an
+	// overuse.
+	constexpr double FractionAfterOveruse{ 0.85 };
+
+	// Options of a rate control running in the sending endpoint.
+	const RTC::BWE::AimdRateControl::AimdRateControlOptions sendSideOptions{ .sendSide = true };
+
+	SECTION("the increase rate has a floor of 4 kbps per second")
+	{
+		RTC::BWE::AimdRateControl aimdRateControl;
+
+		aimdRateControl.SetEstimate(30000, InitialTimeUs);
+
+		REQUIRE(aimdRateControl.GetNearMaxIncreaseRateBpsPerSecond() == 4000);
+	}
+
+	SECTION("the increase rate is 5 kbps per second at 90 kbps and 200 ms of RTT")
+	{
+		RTC::BWE::AimdRateControl aimdRateControl;
+
+		aimdRateControl.SetEstimate(90000, InitialTimeUs);
+
+		REQUIRE(aimdRateControl.GetNearMaxIncreaseRateBpsPerSecond() == 5000);
+	}
+
+	SECTION("the increase rate is 5 kbps per second at 60 kbps and 100 ms of RTT")
+	{
+		RTC::BWE::AimdRateControl aimdRateControl;
+
+		aimdRateControl.SetEstimate(60000, InitialTimeUs);
+		aimdRateControl.SetRttUs(100 * 1000);
+
+		REQUIRE(aimdRateControl.GetNearMaxIncreaseRateBpsPerSecond() == 5000);
+	}
+
+	SECTION("the increase rate grows with the bitrate")
+	{
+		constexpr int64_t Bitrate{ 300000 };
+
+		RTC::BWE::AimdRateControl aimdRateControl;
+
+		aimdRateControl.SetEstimate(Bitrate, InitialTimeUs);
+		aimdRateControl.Update(
+		  { .bandwidthUsage = RTC::BWE::Types::BandwidthUsage::OVERUSING, .estimatedThroughput = Bitrate },
+		  InitialTimeUs);
+
+		REQUIRE_THAT(
+		  aimdRateControl.GetNearMaxIncreaseRateBpsPerSecond(), Catch::Matchers::WithinAbs(14000, 1000));
+	}
+
+	SECTION("the bitrate is limited by the acknowledged one")
+	{
+		constexpr int64_t AckedBitrate{ 10000 };
+
+		RTC::BWE::AimdRateControl aimdRateControl;
+
+		int64_t nowUs{ InitialTimeUs };
+
+		aimdRateControl.SetEstimate(AckedBitrate, nowUs);
+
+		while (nowUs - InitialTimeUs < 20 * 1000 * 1000)
+		{
+			aimdRateControl.Update(
+			  { .bandwidthUsage      = RTC::BWE::Types::BandwidthUsage::NORMAL,
+				  .estimatedThroughput = AckedBitrate },
+			  nowUs);
+
+			nowUs += 100 * 1000;
+		}
+
+		REQUIRE(aimdRateControl.IsValidEstimate());
+		REQUIRE(aimdRateControl.GetLatestEstimate() == (3 * AckedBitrate / 2) + 10000);
+	}
+
+	SECTION("a decreasing acknowledged bitrate doesn't drag the estimate down")
+	{
+		constexpr int64_t AckedBitrate{ 10000 };
+
+		RTC::BWE::AimdRateControl aimdRateControl;
+
+		int64_t nowUs{ InitialTimeUs };
+
+		aimdRateControl.SetEstimate(AckedBitrate, nowUs);
+
+		while (nowUs - InitialTimeUs < 20 * 1000 * 1000)
+		{
+			aimdRateControl.Update(
+			  { .bandwidthUsage      = RTC::BWE::Types::BandwidthUsage::NORMAL,
+				  .estimatedThroughput = AckedBitrate },
+			  nowUs);
+
+			nowUs += 100 * 1000;
+		}
+
+		REQUIRE(aimdRateControl.IsValidEstimate());
+
+		// The estimate must not be reduced to 1.5x what is being acknowledged, but
+		// it must not grow any further either.
+		const int64_t prevEstimate = aimdRateControl.GetLatestEstimate();
+
+		aimdRateControl.Update(
+		  { .bandwidthUsage      = RTC::BWE::Types::BandwidthUsage::NORMAL,
+			  .estimatedThroughput = AckedBitrate / 2 },
+		  nowUs);
+
+		REQUIRE(aimdRateControl.GetLatestEstimate() == prevEstimate);
+		// And it's still the value it had grown to, rather than both being wrong.
+		REQUIRE_THAT(
+		  static_cast<double>(aimdRateControl.GetLatestEstimate()),
+		  Catch::Matchers::WithinAbs((1.5 * AckedBitrate) + 10000, 2000));
+	}
+
+	SECTION("an overuse drops the bitrate to the backoff fraction of the throughput")
+	{
+		constexpr int64_t InitialBitrate{ 264000 };
+		constexpr int64_t UpdatedBitrate{ 216000 };
+
+		RTC::BWE::AimdRateControl aimdRateControl;
+
+		const auto ackedBitrate =
+		  static_cast<int64_t>(std::llround((UpdatedBitrate + 5000) / FractionAfterOveruse));
+
+		int64_t nowUs{ InitialTimeUs };
+
+		aimdRateControl.SetEstimate(InitialBitrate, nowUs);
+
+		nowUs += 100 * 1000;
+
+		aimdRateControl.Update(
+		  { .bandwidthUsage      = RTC::BWE::Types::BandwidthUsage::OVERUSING,
+			  .estimatedThroughput = ackedBitrate },
+		  nowUs);
+
+		REQUIRE(aimdRateControl.GetLatestEstimate() == UpdatedBitrate);
+		// The increase rate at 216 kbps is 12 kbps per second.
+		REQUIRE(aimdRateControl.GetNearMaxIncreaseRateBpsPerSecond() == 12000);
+	}
+
+	SECTION("the bitrate stays bounded while no throughput is measured")
+	{
+		constexpr int64_t InitialBitrate{ 123000 };
+
+		RTC::BWE::AimdRateControl aimdRateControl;
+
+		int64_t nowUs{ InitialTimeUs };
+
+		aimdRateControl.Update(
+		  { .bandwidthUsage      = RTC::BWE::Types::BandwidthUsage::NORMAL,
+			  .estimatedThroughput = InitialBitrate },
+		  nowUs);
+
+		// The initial bitrate is taken from what has been measured for five seconds.
+		nowUs += (5 * 1000 * 1000) + 1000;
+
+		aimdRateControl.Update(
+		  { .bandwidthUsage      = RTC::BWE::Types::BandwidthUsage::NORMAL,
+			  .estimatedThroughput = InitialBitrate },
+		  nowUs);
+
+		for (int i{ 0 }; i < 100; ++i)
+		{
+			aimdRateControl.Update(
+			  { .bandwidthUsage      = RTC::BWE::Types::BandwidthUsage::NORMAL,
+				  .estimatedThroughput = std::nullopt },
+			  nowUs);
+
+			nowUs += 100 * 1000;
+		}
+
+		REQUIRE(aimdRateControl.GetLatestEstimate() <= (3 * InitialBitrate / 2) + 10000);
+	}
+
+	SECTION("the estimate doesn't increase in ALR when so configured")
+	{
+		constexpr int64_t InitialBitrate{ 123000 };
+
+		// While in an application limited region the network gives no feedback that
+		// could tell whether a higher estimate is correct, so it must not grow.
+		auto options = sendSideOptions;
+
+		options.noBitrateIncreaseInAlr = true;
+
+		RTC::BWE::AimdRateControl aimdRateControl(options);
+
+		int64_t nowUs{ InitialTimeUs };
+
+		aimdRateControl.SetEstimate(InitialBitrate, nowUs);
+		aimdRateControl.SetInApplicationLimitedRegion(true);
+		aimdRateControl.Update(
+		  { .bandwidthUsage      = RTC::BWE::Types::BandwidthUsage::NORMAL,
+			  .estimatedThroughput = InitialBitrate },
+		  nowUs);
+
+		REQUIRE(aimdRateControl.GetLatestEstimate() == InitialBitrate);
+
+		for (int i{ 0 }; i < 100; ++i)
+		{
+			aimdRateControl.Update(
+			  { .bandwidthUsage      = RTC::BWE::Types::BandwidthUsage::NORMAL,
+				  .estimatedThroughput = std::nullopt },
+			  nowUs);
+
+			nowUs += 100 * 1000;
+		}
+
+		REQUIRE(aimdRateControl.GetLatestEstimate() == InitialBitrate);
+	}
+
+	SECTION("the estimate can still be set from outside while in ALR")
+	{
+		constexpr int64_t InitialBitrate{ 123000 };
+
+		auto options = sendSideOptions;
+
+		options.noBitrateIncreaseInAlr = true;
+
+		RTC::BWE::AimdRateControl aimdRateControl(options);
+
+		aimdRateControl.SetEstimate(InitialBitrate, InitialTimeUs);
+		aimdRateControl.SetInApplicationLimitedRegion(true);
+
+		REQUIRE(aimdRateControl.GetLatestEstimate() == InitialBitrate);
+
+		aimdRateControl.SetEstimate(2 * InitialBitrate, InitialTimeUs);
+
+		REQUIRE(aimdRateControl.GetLatestEstimate() == 2 * InitialBitrate);
+	}
+
+	SECTION("the estimate increases while not in ALR")
+	{
+		constexpr int64_t InitialBitrate{ 123000 };
+
+		// Not being in ALR must let the estimate grow, so that it cannot get stuck
+		// at a given bitrate.
+		auto options = sendSideOptions;
+
+		options.noBitrateIncreaseInAlr = true;
+
+		RTC::BWE::AimdRateControl aimdRateControl(options);
+
+		int64_t nowUs{ InitialTimeUs };
+
+		aimdRateControl.SetEstimate(InitialBitrate, nowUs);
+		aimdRateControl.SetInApplicationLimitedRegion(false);
+		aimdRateControl.Update(
+		  { .bandwidthUsage      = RTC::BWE::Types::BandwidthUsage::NORMAL,
+			  .estimatedThroughput = InitialBitrate },
+		  nowUs);
+
+		for (int i{ 0 }; i < 100; ++i)
+		{
+			aimdRateControl.Update(
+			  { .bandwidthUsage      = RTC::BWE::Types::BandwidthUsage::NORMAL,
+				  .estimatedThroughput = std::nullopt },
+			  nowUs);
+
+			nowUs += 100 * 1000;
+		}
+
+		REQUIRE(aimdRateControl.GetLatestEstimate() > InitialBitrate);
+	}
+
+	SECTION("the estimate is upper limited by the network state estimate")
+	{
+		constexpr int64_t LinkCapacityUpper{ 400000 };
+
+		const RTC::BWE::Types::NetworkStateEstimate networkEstimate{ .linkCapacityUpper =
+		                                                               LinkCapacityUpper };
+
+		RTC::BWE::AimdRateControl aimdRateControl(sendSideOptions);
+
+		aimdRateControl.SetEstimate(300000, InitialTimeUs);
+		aimdRateControl.SetNetworkStateEstimate(networkEstimate);
+		aimdRateControl.SetEstimate(500000, InitialTimeUs);
+
+		REQUIRE(aimdRateControl.GetLatestEstimate() == LinkCapacityUpper);
+	}
+
+	SECTION("the current bitrate is the lowest possible upper limit")
+	{
+		constexpr int64_t CurrentBitrate{ 500000 };
+
+		// Below the current bitrate, so it must not drag it down.
+		const RTC::BWE::Types::NetworkStateEstimate networkEstimate{ .linkCapacityUpper = 300000 };
+
+		RTC::BWE::AimdRateControl aimdRateControl(sendSideOptions);
+
+		aimdRateControl.SetEstimate(CurrentBitrate, InitialTimeUs);
+
+		REQUIRE(aimdRateControl.GetLatestEstimate() == CurrentBitrate);
+
+		aimdRateControl.SetNetworkStateEstimate(networkEstimate);
+		aimdRateControl.SetEstimate(700000, InitialTimeUs);
+
+		REQUIRE(aimdRateControl.GetLatestEstimate() == CurrentBitrate);
+	}
+
+	SECTION("the current bitrate is not the lowest possible upper limit when so configured")
+	{
+		constexpr int64_t LinkCapacityUpper{ 300000 };
+
+		const RTC::BWE::Types::NetworkStateEstimate networkEstimate{ .linkCapacityUpper =
+		                                                               LinkCapacityUpper };
+
+		auto options = sendSideOptions;
+
+		options.useCurrentEstimateAsMinUpperBound = false;
+
+		RTC::BWE::AimdRateControl aimdRateControl(options);
+
+		aimdRateControl.SetEstimate(500000, InitialTimeUs);
+
+		REQUIRE(aimdRateControl.GetLatestEstimate() == 500000);
+
+		aimdRateControl.SetNetworkStateEstimate(networkEstimate);
+		aimdRateControl.SetEstimate(700000, InitialTimeUs);
+
+		REQUIRE(aimdRateControl.GetLatestEstimate() == LinkCapacityUpper);
+	}
+
+	SECTION("the estimate is lower limited by the network state estimate")
+	{
+		constexpr int64_t LinkCapacityLower{ 400000 };
+
+		const RTC::BWE::Types::NetworkStateEstimate networkEstimate{ .linkCapacityLower =
+		                                                               LinkCapacityLower };
+
+		RTC::BWE::AimdRateControl aimdRateControl(sendSideOptions);
+
+		aimdRateControl.SetNetworkStateEstimate(networkEstimate);
+		aimdRateControl.SetEstimate(100000, InitialTimeUs);
+
+		REQUIRE(
+		  aimdRateControl.GetLatestEstimate() == std::llround(LinkCapacityLower * FractionAfterOveruse));
+	}
+
+	SECTION("setting an estimate below the network state estimate is ignored")
+	{
+		constexpr int64_t CurrentBitrate{ 200000 };
+
+		const RTC::BWE::Types::NetworkStateEstimate networkEstimate{ .linkCapacityLower = 400000 };
+
+		RTC::BWE::AimdRateControl aimdRateControl(sendSideOptions);
+
+		aimdRateControl.SetEstimate(CurrentBitrate, InitialTimeUs);
+
+		REQUIRE(aimdRateControl.GetLatestEstimate() == CurrentBitrate);
+
+		aimdRateControl.SetNetworkStateEstimate(networkEstimate);
+
+		// Ignored, since it's lower than the backoff fraction of the network state
+		// estimate.
+		aimdRateControl.SetEstimate(100000, InitialTimeUs);
+
+		REQUIRE(aimdRateControl.GetLatestEstimate() == CurrentBitrate);
+	}
+
+	SECTION("the estimate is not limited by the network state estimate when so configured")
+	{
+		constexpr int64_t InitialBitrate{ 123000 };
+		constexpr int64_t LinkCapacityUpper{ 150000 };
+
+		const RTC::BWE::Types::NetworkStateEstimate networkEstimate{ .linkCapacityUpper =
+		                                                               LinkCapacityUpper };
+
+		auto options = sendSideOptions;
+
+		options.estimateBoundedIncrease = false;
+
+		RTC::BWE::AimdRateControl aimdRateControl(options);
+
+		int64_t nowUs{ InitialTimeUs };
+
+		aimdRateControl.SetEstimate(InitialBitrate, nowUs);
+		aimdRateControl.SetInApplicationLimitedRegion(false);
+		aimdRateControl.SetNetworkStateEstimate(networkEstimate);
+
+		for (int i{ 0 }; i < 100; ++i)
+		{
+			aimdRateControl.Update(
+			  { .bandwidthUsage      = RTC::BWE::Types::BandwidthUsage::NORMAL,
+				  .estimatedThroughput = std::nullopt },
+			  nowUs);
+
+			nowUs += 100 * 1000;
+		}
+
+		REQUIRE(aimdRateControl.GetLatestEstimate() > LinkCapacityUpper);
+	}
+}