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

Call Call::GetStats() from the correct thread in our bandwidth tests.

Browse Source 
Bug: webrtc:10847
Change-Id: Ief8cdd72f9d5b600d5306c00c1d249c29fb20396
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/148063
Reviewed-by: Magnus Flodman <mflodman@webrtc.org>
Commit-Queue: Tommi <tommi@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#28765}
This commit is contained in:
Tommi
2019-08-05 15:08:17 +02:00
committed by Commit Bot
parent 5e005f4b2d
commit e80885a89c
1 changed files with 64 additions and 60 deletions
Download Patch File Download Diff File Expand all files Collapse all files

124
video/end_to_end_tests/bandwidth_tests.cc
View File

@ -79,12 +79,14 @@ TEST_F(BandwidthEndToEndTest, ReceiveStreamSendsRemb) {
class BandwidthStatsTest : public test::EndToEndTest { class BandwidthStatsTest : public test::EndToEndTest {
public: public:
explicit BandwidthStatsTest(bool send_side_bwe) BandwidthStatsTest(bool send_side_bwe,
test::SingleThreadedTaskQueueForTesting* task_queue)
: EndToEndTest(test::CallTest::kDefaultTimeoutMs), : EndToEndTest(test::CallTest::kDefaultTimeoutMs),
sender_call_(nullptr), sender_call_(nullptr),
receiver_call_(nullptr), receiver_call_(nullptr),
has_seen_pacer_delay_(false), has_seen_pacer_delay_(false),
send_side_bwe_(send_side_bwe) {} send_side_bwe_(send_side_bwe),
task_queue_(task_queue) {}
void ModifyVideoConfigs( void ModifyVideoConfigs(
VideoSendStream::Config* send_config, VideoSendStream::Config* send_config,
@ -99,15 +101,22 @@ class BandwidthStatsTest : public test::EndToEndTest {
} }
} }
// Called on the pacer thread.
Action OnSendRtp(const uint8_t* packet, size_t length) override { Action OnSendRtp(const uint8_t* packet, size_t length) override {
Call::Stats sender_stats = sender_call_->GetStats(); // Stats need to be fetched on the thread where the caller objects were
Call::Stats receiver_stats = receiver_call_->GetStats(); // constructed.
if (!has_seen_pacer_delay_) task_queue_->PostTask([this]() {
has_seen_pacer_delay_ = sender_stats.pacer_delay_ms > 0; Call::Stats sender_stats = sender_call_->GetStats();
if (sender_stats.send_bandwidth_bps > 0 && has_seen_pacer_delay_) { if (!has_seen_pacer_delay_)
if (send_side_bwe_ || receiver_stats.recv_bandwidth_bps > 0) has_seen_pacer_delay_ = sender_stats.pacer_delay_ms > 0;
observation_complete_.Set();
} if (sender_stats.send_bandwidth_bps > 0 && has_seen_pacer_delay_) {
Call::Stats receiver_stats = receiver_call_->GetStats();
if (send_side_bwe_ || receiver_stats.recv_bandwidth_bps > 0)
observation_complete_.Set();
}
});
return SEND_PACKET; return SEND_PACKET;
} }
@ -126,15 +135,16 @@ class BandwidthStatsTest : public test::EndToEndTest {
Call* receiver_call_; Call* receiver_call_;
bool has_seen_pacer_delay_; bool has_seen_pacer_delay_;
const bool send_side_bwe_; const bool send_side_bwe_;
test::SingleThreadedTaskQueueForTesting* const task_queue_;
}; };
TEST_F(BandwidthEndToEndTest, VerifySendSideBweStats) { TEST_F(BandwidthEndToEndTest, VerifySendSideBweStats) {
BandwidthStatsTest test(true); BandwidthStatsTest test(true, &task_queue_);
RunBaseTest(&test); RunBaseTest(&test);
} }
TEST_F(BandwidthEndToEndTest, VerifyRecvSideBweStats) { TEST_F(BandwidthEndToEndTest, VerifyRecvSideBweStats) {
BandwidthStatsTest test(false); BandwidthStatsTest test(false, &task_queue_);
RunBaseTest(&test); RunBaseTest(&test);
} }
@ -146,18 +156,16 @@ TEST_F(BandwidthEndToEndTest, VerifyRecvSideBweStats) {
TEST_F(BandwidthEndToEndTest, RembWithSendSideBwe) { TEST_F(BandwidthEndToEndTest, RembWithSendSideBwe) {
class BweObserver : public test::EndToEndTest { class BweObserver : public test::EndToEndTest {
public: public:
BweObserver() explicit BweObserver(test::SingleThreadedTaskQueueForTesting* task_queue)
: EndToEndTest(kDefaultTimeoutMs), : EndToEndTest(kDefaultTimeoutMs),
sender_call_(nullptr), sender_call_(nullptr),
clock_(Clock::GetRealTimeClock()), clock_(Clock::GetRealTimeClock()),
sender_ssrc_(0), sender_ssrc_(0),
remb_bitrate_bps_(1000000), remb_bitrate_bps_(1000000),
receive_transport_(nullptr), receive_transport_(nullptr),
poller_thread_(&BitrateStatsPollingThread,
this,
"BitrateStatsPollingThread"),
state_(kWaitForFirstRampUp), state_(kWaitForFirstRampUp),
retransmission_rate_limiter_(clock_, 1000) {} retransmission_rate_limiter_(clock_, 1000),
task_queue_(task_queue) {}
~BweObserver() {} ~BweObserver() {}
@ -200,56 +208,52 @@ TEST_F(BandwidthEndToEndTest, RembWithSendSideBwe) {
} }
void OnCallsCreated(Call* sender_call, Call* receiver_call) override { void OnCallsCreated(Call* sender_call, Call* receiver_call) override {
RTC_DCHECK(sender_call);
sender_call_ = sender_call; sender_call_ = sender_call;
} pending_task_ = task_queue_->PostTask([this]() { PollStats(); });
static void BitrateStatsPollingThread(void* obj) {
static_cast<BweObserver*>(obj)->PollStats();
} }
void PollStats() { void PollStats() {
do { pending_task_ = ~0; // for debugging purposes indicate no pending task.
if (sender_call_) { Call::Stats stats = sender_call_->GetStats();
Call::Stats stats = sender_call_->GetStats(); switch (state_) {
switch (state_) { case kWaitForFirstRampUp:
case kWaitForFirstRampUp: if (stats.send_bandwidth_bps >= remb_bitrate_bps_) {
if (stats.send_bandwidth_bps >= remb_bitrate_bps_) { state_ = kWaitForRemb;
state_ = kWaitForRemb; remb_bitrate_bps_ /= 2;
remb_bitrate_bps_ /= 2; rtp_rtcp_->SetRemb(
rtp_rtcp_->SetRemb( remb_bitrate_bps_,
remb_bitrate_bps_, std::vector<uint32_t>(&sender_ssrc_, &sender_ssrc_ + 1));
std::vector<uint32_t>(&sender_ssrc_, &sender_ssrc_ + 1)); rtp_rtcp_->SendRTCP(kRtcpRr);
rtp_rtcp_->SendRTCP(kRtcpRr);
}
break;
case kWaitForRemb:
if (stats.send_bandwidth_bps == remb_bitrate_bps_) {
state_ = kWaitForSecondRampUp;
remb_bitrate_bps_ *= 2;
rtp_rtcp_->SetRemb(
remb_bitrate_bps_,
std::vector<uint32_t>(&sender_ssrc_, &sender_ssrc_ + 1));
rtp_rtcp_->SendRTCP(kRtcpRr);
}
break;
case kWaitForSecondRampUp:
if (stats.send_bandwidth_bps == remb_bitrate_bps_) {
observation_complete_.Set();
}
break;
} }
} break;
} while (!stop_event_.Wait(1000));
case kWaitForRemb:
if (stats.send_bandwidth_bps == remb_bitrate_bps_) {
state_ = kWaitForSecondRampUp;
remb_bitrate_bps_ *= 2;
rtp_rtcp_->SetRemb(
remb_bitrate_bps_,
std::vector<uint32_t>(&sender_ssrc_, &sender_ssrc_ + 1));
rtp_rtcp_->SendRTCP(kRtcpRr);
}
break;
case kWaitForSecondRampUp:
if (stats.send_bandwidth_bps == remb_bitrate_bps_) {
observation_complete_.Set();
return;
}
break;
}
pending_task_ =
task_queue_->PostDelayedTask([this]() { PollStats(); }, 1000);
} }
void PerformTest() override { void PerformTest() override {
poller_thread_.Start();
EXPECT_TRUE(Wait()) EXPECT_TRUE(Wait())
<< "Timed out while waiting for bitrate to change according to REMB."; << "Timed out while waiting for bitrate to change according to REMB.";
stop_event_.Set();
poller_thread_.Stop();
} }
private: private:
@ -261,11 +265,11 @@ TEST_F(BandwidthEndToEndTest, RembWithSendSideBwe) {
int remb_bitrate_bps_; int remb_bitrate_bps_;
std::unique_ptr<RtpRtcp> rtp_rtcp_; std::unique_ptr<RtpRtcp> rtp_rtcp_;
test::PacketTransport* receive_transport_; test::PacketTransport* receive_transport_;
rtc::Event stop_event_;
rtc::PlatformThread poller_thread_;
TestState state_; TestState state_;
RateLimiter retransmission_rate_limiter_; RateLimiter retransmission_rate_limiter_;
} test; test::SingleThreadedTaskQueueForTesting* const task_queue_;
test::SingleThreadedTaskQueueForTesting::TaskId pending_task_ = ~0;
} test(&task_queue_);
RunBaseTest(&test); RunBaseTest(&test);
} }