zqz/platform-external-webrtc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Revert "Renamed constants in unit tests for paced sender."

Browse Source 
This reverts commit 9af0a672c277c7d062c9957acdaa641d2e1a93ac.

Reason for revert: Conflicts with reverting https://webrtc-review.googlesource.com/c/src/+/48000

Original change's description:
> Renamed constants in unit tests for paced sender.
> 
> Since paced sender no longer has an internal multiplier, the constants
> used for the unit tests were changed from supplying kTargetBitrateBps *
> kPaceMultiplier at each usage to simply using the new constant
> kPacingRateBps, simplifying the test code.
> 
> The function PacketsSentPerInterval was introduced as the value was
> computed and explained several times over in the different tests.
> 
> Bug: None
> Change-Id: Ib1cf9b40194272b1529abb02d49cae6b8732d1e6
> Reviewed-on: https://webrtc-review.googlesource.com/50443
> Reviewed-by: Stefan Holmer <stefan@webrtc.org>
> Commit-Queue: Sebastian Jansson <srte@webrtc.org>
> Cr-Commit-Position: refs/heads/master@{#21999}

TBR=stefan@webrtc.org,srte@webrtc.org

Change-Id: Icb19b0796199a5fc30e531339d5fb13bfec9f329
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Bug: None
Reviewed-on: https://webrtc-review.googlesource.com/53064
Reviewed-by: Danil Chapovalov <danilchap@webrtc.org>
Commit-Queue: Danil Chapovalov <danilchap@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#22015}
This commit is contained in:
Danil Chapovalov
2018-02-14 10:48:49 +00:00
committed by Commit Bot
parent 516036f945
commit 74a369c48d
1 changed files with 54 additions and 29 deletions
Download Patch File Download Diff File Expand all files Collapse all files

83
modules/pacing/paced_sender_unittest.cc
View File

@ -23,8 +23,6 @@ using testing::_;
using testing::Field; using testing::Field;
using testing::Return; using testing::Return;
namespace webrtc {
namespace test {
namespace { namespace {
constexpr unsigned kFirstClusterBps = 900000; constexpr unsigned kFirstClusterBps = 900000;
constexpr unsigned kSecondClusterBps = 1800000; constexpr unsigned kSecondClusterBps = 1800000;
@ -35,12 +33,13 @@ constexpr unsigned kSecondClusterBps = 1800000;
constexpr int kBitrateProbingError = 150000; constexpr int kBitrateProbingError = 150000;
const float kPaceMultiplier = 2.5f; const float kPaceMultiplier = 2.5f;
const int kTargetBitrateBps = 800000;
const int kPacingRateBps = kTargetBitrateBps * kPaceMultiplier;
const int kPaddingRateBps = kTargetBitrateBps;
} // namespace } // namespace
namespace webrtc {
namespace test {
static const int kTargetBitrateBps = 800000;
class MockPacedSenderCallback : public PacedSender::PacketSender { class MockPacedSenderCallback : public PacedSender::PacketSender {
public: public:
MOCK_METHOD5(TimeToSendPacket, MOCK_METHOD5(TimeToSendPacket,
@ -119,19 +118,11 @@ class PacedSenderTest : public testing::TestWithParam<std::string> {
// have to enable probing, either by creating a new PacedSender instance or // have to enable probing, either by creating a new PacedSender instance or
// by calling SetProbingEnabled(true). // by calling SetProbingEnabled(true).
send_bucket_->SetProbingEnabled(false); send_bucket_->SetProbingEnabled(false);
send_bucket_->SetPacingRates(kPacingRateBps, 0); send_bucket_->SetPacingRates(kTargetBitrateBps * kPaceMultiplier, 0);
clock_.AdvanceTimeMilliseconds(send_bucket_->TimeUntilNextProcess()); clock_.AdvanceTimeMilliseconds(send_bucket_->TimeUntilNextProcess());
} }
size_t PacketsSentPerInterval(size_t packet_size) const {
// The pacer can send 5 packets during a send interval when using the
// default testing pacing rate and packet_size = 250.
const size_t kBitsPerByte = 8;
const size_t kIntervalsPerSecond = 200;
return kPacingRateBps / (kBitsPerByte * packet_size * kIntervalsPerSecond);
}
void SendAndExpectPacket(PacedSender::Priority priority, void SendAndExpectPacket(PacedSender::Priority priority,
uint32_t ssrc, uint32_t ssrc,
uint16_t sequence_number, uint16_t sequence_number,
@ -178,7 +169,11 @@ TEST_P(PacedSenderTest, FirstSentPacketTimeIsSet) {
TEST_P(PacedSenderTest, QueuePacket) { TEST_P(PacedSenderTest, QueuePacket) {
uint32_t ssrc = 12345; uint32_t ssrc = 12345;
uint16_t sequence_number = 1234; uint16_t sequence_number = 1234;
const size_t packets_to_send = PacketsSentPerInterval(250); // Due to the multiplicative factor we can send 5 packets during a send
// interval. (network capacity * multiplier / (8 bits per byte *
// (packet size * #send intervals per second)
const size_t packets_to_send =
kTargetBitrateBps * kPaceMultiplier / (8 * 250 * 200);
for (size_t i = 0; i < packets_to_send; ++i) { for (size_t i = 0; i < packets_to_send; ++i) {
SendAndExpectPacket(PacedSender::kNormalPriority, ssrc, sequence_number++, SendAndExpectPacket(PacedSender::kNormalPriority, ssrc, sequence_number++,
clock_.TimeInMilliseconds(), 250, false); clock_.TimeInMilliseconds(), 250, false);
@ -223,7 +218,11 @@ TEST_P(PacedSenderTest, PaceQueuedPackets) {
uint32_t ssrc = 12345; uint32_t ssrc = 12345;
uint16_t sequence_number = 1234; uint16_t sequence_number = 1234;
const size_t packets_to_send_per_interval = PacketsSentPerInterval(250); // Due to the multiplicative factor we can send 5 packets during a send
// interval. (network capacity * multiplier / (8 bits per byte *
// (packet size * #send intervals per second)
const size_t packets_to_send_per_interval =
kTargetBitrateBps * kPaceMultiplier / (8 * 250 * 200);
for (size_t i = 0; i < packets_to_send_per_interval; ++i) { for (size_t i = 0; i < packets_to_send_per_interval; ++i) {
SendAndExpectPacket(PacedSender::kNormalPriority, ssrc, sequence_number++, SendAndExpectPacket(PacedSender::kNormalPriority, ssrc, sequence_number++,
clock_.TimeInMilliseconds(), 250, false); clock_.TimeInMilliseconds(), 250, false);
@ -308,9 +307,14 @@ TEST_P(PacedSenderTest, Padding) {
uint32_t ssrc = 12345; uint32_t ssrc = 12345;
uint16_t sequence_number = 1234; uint16_t sequence_number = 1234;
send_bucket_->SetPacingRates(kPacingRateBps, kPaddingRateBps); send_bucket_->SetPacingRates(kTargetBitrateBps * kPaceMultiplier,
kTargetBitrateBps);
const size_t packets_to_send_per_interval = PacketsSentPerInterval(250); // Due to the multiplicative factor we can send 5 packets during a send
// interval. (network capacity * multiplier / (8 bits per byte *
// (packet size * #send intervals per second)
const size_t packets_to_send_per_interval =
kTargetBitrateBps * kPaceMultiplier / (8 * 250 * 200);
for (size_t i = 0; i < packets_to_send_per_interval; ++i) { for (size_t i = 0; i < packets_to_send_per_interval; ++i) {
SendAndExpectPacket(PacedSender::kNormalPriority, ssrc, sequence_number++, SendAndExpectPacket(PacedSender::kNormalPriority, ssrc, sequence_number++,
clock_.TimeInMilliseconds(), 250, false); clock_.TimeInMilliseconds(), 250, false);
@ -340,7 +344,8 @@ TEST_P(PacedSenderTest, Padding) {
} }
TEST_P(PacedSenderTest, NoPaddingBeforeNormalPacket) { TEST_P(PacedSenderTest, NoPaddingBeforeNormalPacket) {
send_bucket_->SetPacingRates(kPacingRateBps, kPaddingRateBps); send_bucket_->SetPacingRates(kTargetBitrateBps * kPaceMultiplier,
kTargetBitrateBps);
EXPECT_CALL(callback_, TimeToSendPadding(_, _)).Times(0); EXPECT_CALL(callback_, TimeToSendPadding(_, _)).Times(0);
send_bucket_->Process(); send_bucket_->Process();
@ -367,7 +372,8 @@ TEST_P(PacedSenderTest, VerifyPaddingUpToBitrate) {
int64_t capture_time_ms = 56789; int64_t capture_time_ms = 56789;
const int kTimeStep = 5; const int kTimeStep = 5;
const int64_t kBitrateWindow = 100; const int64_t kBitrateWindow = 100;
send_bucket_->SetPacingRates(kPacingRateBps, kPaddingRateBps); send_bucket_->SetPacingRates(kTargetBitrateBps * kPaceMultiplier,
kTargetBitrateBps);
int64_t start_time = clock_.TimeInMilliseconds(); int64_t start_time = clock_.TimeInMilliseconds();
while (clock_.TimeInMilliseconds() - start_time < kBitrateWindow) { while (clock_.TimeInMilliseconds() - start_time < kBitrateWindow) {
@ -394,7 +400,8 @@ TEST_P(PacedSenderTest, VerifyAverageBitrateVaryingMediaPayload) {
PacedSenderPadding callback; PacedSenderPadding callback;
send_bucket_.reset(new PacedSender(&clock_, &callback, nullptr)); send_bucket_.reset(new PacedSender(&clock_, &callback, nullptr));
send_bucket_->SetProbingEnabled(false); send_bucket_->SetProbingEnabled(false);
send_bucket_->SetPacingRates(kPacingRateBps, kPaddingRateBps); send_bucket_->SetPacingRates(kTargetBitrateBps * kPaceMultiplier,
kTargetBitrateBps);
int64_t start_time = clock_.TimeInMilliseconds(); int64_t start_time = clock_.TimeInMilliseconds();
size_t media_bytes = 0; size_t media_bytes = 0;
@ -408,7 +415,7 @@ TEST_P(PacedSenderTest, VerifyAverageBitrateVaryingMediaPayload) {
clock_.AdvanceTimeMilliseconds(kTimeStep); clock_.AdvanceTimeMilliseconds(kTimeStep);
send_bucket_->Process(); send_bucket_->Process();
} }
EXPECT_NEAR(kPaddingRateBps / 1000, EXPECT_NEAR(kTargetBitrateBps / 1000,
static_cast<int>(8 * (media_bytes + callback.padding_sent()) / static_cast<int>(8 * (media_bytes + callback.padding_sent()) /
kBitrateWindow), kBitrateWindow),
1); 1);
@ -421,7 +428,11 @@ TEST_P(PacedSenderTest, Priority) {
int64_t capture_time_ms = 56789; int64_t capture_time_ms = 56789;
int64_t capture_time_ms_low_priority = 1234567; int64_t capture_time_ms_low_priority = 1234567;
const size_t packets_to_send_per_interval = PacketsSentPerInterval(250); // Due to the multiplicative factor we can send 5 packets during a send
// interval. (network capacity * multiplier / (8 bits per byte *
// (packet size * #send intervals per second)
const size_t packets_to_send_per_interval =
kTargetBitrateBps * kPaceMultiplier / (8 * 250 * 200);
for (size_t i = 0; i < packets_to_send_per_interval; ++i) { for (size_t i = 0; i < packets_to_send_per_interval; ++i) {
SendAndExpectPacket(PacedSender::kNormalPriority, ssrc, sequence_number++, SendAndExpectPacket(PacedSender::kNormalPriority, ssrc, sequence_number++,
clock_.TimeInMilliseconds(), 250, false); clock_.TimeInMilliseconds(), 250, false);
@ -471,7 +482,11 @@ TEST_P(PacedSenderTest, RetransmissionPriority) {
int64_t capture_time_ms = 45678; int64_t capture_time_ms = 45678;
int64_t capture_time_ms_retransmission = 56789; int64_t capture_time_ms_retransmission = 56789;
const size_t packets_to_send_per_interval = PacketsSentPerInterval(250); // Due to the multiplicative factor we can send 5 packets during a send
// interval. (network capacity * multiplier / (8 bits per byte *
// (packet size * #send intervals per second)
const size_t packets_to_send_per_interval =
kTargetBitrateBps * kPaceMultiplier / (8 * 250 * 200);
send_bucket_->Process(); send_bucket_->Process();
EXPECT_EQ(0u, send_bucket_->QueueSizePackets()); EXPECT_EQ(0u, send_bucket_->QueueSizePackets());
@ -528,7 +543,11 @@ TEST_P(PacedSenderTest, HighPrioDoesntAffectBudget) {
} }
send_bucket_->Process(); send_bucket_->Process();
// Low prio packets does affect the budget. // Low prio packets does affect the budget.
const size_t packets_to_send_per_interval = PacketsSentPerInterval(250); // Due to the multiplicative factor we can send 5 packets during a send
// interval. (network capacity * multiplier / (8 bits per byte *
// (packet size * #send intervals per second)
const size_t packets_to_send_per_interval =
kTargetBitrateBps * kPaceMultiplier / (8 * 250 * 200);
for (size_t i = 0; i < packets_to_send_per_interval; ++i) { for (size_t i = 0; i < packets_to_send_per_interval; ++i) {
SendAndExpectPacket(PacedSender::kLowPriority, ssrc, sequence_number++, SendAndExpectPacket(PacedSender::kLowPriority, ssrc, sequence_number++,
clock_.TimeInMilliseconds(), 250, false); clock_.TimeInMilliseconds(), 250, false);
@ -558,7 +577,11 @@ TEST_P(PacedSenderTest, Pause) {
EXPECT_EQ(0, send_bucket_->QueueInMs()); EXPECT_EQ(0, send_bucket_->QueueInMs());
const size_t packets_to_send_per_interval = PacketsSentPerInterval(250); // Due to the multiplicative factor we can send 5 packets during a send
// interval. (network capacity * multiplier / (8 bits per byte *
// (packet size * #send intervals per second)
const size_t packets_to_send_per_interval =
kTargetBitrateBps * kPaceMultiplier / (8 * 250 * 200);
for (size_t i = 0; i < packets_to_send_per_interval; ++i) { for (size_t i = 0; i < packets_to_send_per_interval; ++i) {
SendAndExpectPacket(PacedSender::kNormalPriority, ssrc, sequence_number++, SendAndExpectPacket(PacedSender::kNormalPriority, ssrc, sequence_number++,
clock_.TimeInMilliseconds(), 250, false); clock_.TimeInMilliseconds(), 250, false);
@ -983,7 +1006,8 @@ TEST_P(PacedSenderTest, ProbeClusterId) {
uint16_t sequence_number = 1234; uint16_t sequence_number = 1234;
const size_t kPacketSize = 1200; const size_t kPacketSize = 1200;
send_bucket_->SetPacingRates(kPacingRateBps, kPaddingRateBps); send_bucket_->SetPacingRates(kTargetBitrateBps * kPaceMultiplier,
kTargetBitrateBps);
send_bucket_->SetProbingEnabled(true); send_bucket_->SetProbingEnabled(true);
for (int i = 0; i < 10; ++i) { for (int i = 0; i < 10; ++i) {
send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc, send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc,
@ -1029,7 +1053,8 @@ TEST_P(PacedSenderTest, AvoidBusyLoopOnSendFailure) {
uint16_t sequence_number = 1234; uint16_t sequence_number = 1234;
const size_t kPacketSize = kFirstClusterBps / (8000 / 10); const size_t kPacketSize = kFirstClusterBps / (8000 / 10);
send_bucket_->SetPacingRates(kPacingRateBps, kPaddingRateBps); send_bucket_->SetPacingRates(kTargetBitrateBps * kPaceMultiplier,
kTargetBitrateBps);
send_bucket_->SetProbingEnabled(true); send_bucket_->SetProbingEnabled(true);
send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc, send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc,
sequence_number, clock_.TimeInMilliseconds(), sequence_number, clock_.TimeInMilliseconds(),