Revert r8297 "Introduce PacketReceiver and remove configuration of simulations via the BweTestConfig."
BUG=4173 R=andresp@webrtc.org TBR=andresp@webrtc.org Review URL: https://webrtc-codereview.appspot.com/38029004 Cr-Commit-Position: refs/heads/master@{#8298} git-svn-id: http://webrtc.googlecode.com/svn/trunk@8298 4adac7df-926f-26a2-2b94-8c16560cd09d
This commit is contained in:
stefan@webrtc.org
parent
03c1c103e4
commit
d6e25a5b27
@ -19,34 +19,57 @@ namespace webrtc {
|
||||
namespace testing {
|
||||
namespace bwe {
|
||||
#if BWE_TEST_LOGGING_COMPILE_TIME_ENABLE
|
||||
BweTestConfig::EstimatorConfig CreateEstimatorConfig(
|
||||
int flow_id, bool plot_delay, bool plot_estimate) {
|
||||
static const AbsoluteSendTimeRemoteBitrateEstimatorFactory factory =
|
||||
AbsoluteSendTimeRemoteBitrateEstimatorFactory();
|
||||
|
||||
return BweTestConfig::EstimatorConfig("AST", flow_id, &factory, kAimdControl,
|
||||
kRembEstimator, plot_delay,
|
||||
plot_estimate);
|
||||
}
|
||||
|
||||
BweTestConfig MakeAdaptiveBweTestConfig() {
|
||||
BweTestConfig result;
|
||||
result.estimator_configs.push_back(CreateEstimatorConfig(0, true, true));
|
||||
return result;
|
||||
}
|
||||
|
||||
BweTestConfig MakeMultiFlowBweTestConfig(int flow_count) {
|
||||
BweTestConfig result;
|
||||
for (int i = 0; i < flow_count; ++i) {
|
||||
result.estimator_configs.push_back(CreateEstimatorConfig(i, false, true));
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
// This test fixture is used to instantiate tests running with adaptive video
|
||||
// senders.
|
||||
class BweSimulation : public BweTest,
|
||||
public ::testing::TestWithParam<BandwidthEstimatorType> {
|
||||
public ::testing::TestWithParam<BweTestConfig> {
|
||||
public:
|
||||
BweSimulation() : BweTest() {}
|
||||
virtual ~BweSimulation() {}
|
||||
|
||||
protected:
|
||||
virtual void SetUp() OVERRIDE { BweTest::SetUp(); }
|
||||
virtual void SetUp() {
|
||||
const BweTestConfig& config = GetParam();
|
||||
SetupTestFromConfig(config);
|
||||
}
|
||||
|
||||
private:
|
||||
DISALLOW_COPY_AND_ASSIGN(BweSimulation);
|
||||
};
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(VideoSendersTest,
|
||||
BweSimulation,
|
||||
::testing::Values(kRembEstimator,
|
||||
kFullSendSideEstimator));
|
||||
INSTANTIATE_TEST_CASE_P(VideoSendersTest, BweSimulation,
|
||||
::testing::Values(MakeAdaptiveBweTestConfig()));
|
||||
|
||||
TEST_P(BweSimulation, SprintUplinkTest) {
|
||||
VerboseLogging(true);
|
||||
AdaptiveVideoSource source(0, 30, 300, 0, 0);
|
||||
PacketSender sender(this, &source, GetParam());
|
||||
PacketSender sender(this, &source, kRembEstimator);
|
||||
RateCounterFilter counter1(this, "sender_output");
|
||||
TraceBasedDeliveryFilter filter(this, "link_capacity");
|
||||
RateCounterFilter counter2(this, "receiver_input");
|
||||
PacketReceiver receiver(this, 0, GetParam(), true, true);
|
||||
ASSERT_TRUE(filter.Init(test::ResourcePath("sprint-uplink", "rx")));
|
||||
RunFor(60 * 1000);
|
||||
}
|
||||
@ -54,11 +77,10 @@ TEST_P(BweSimulation, SprintUplinkTest) {
|
||||
TEST_P(BweSimulation, Verizon4gDownlinkTest) {
|
||||
VerboseLogging(true);
|
||||
AdaptiveVideoSource source(0, 30, 300, 0, 0);
|
||||
PacketSender sender(this, &source, GetParam());
|
||||
PacketSender sender(this, &source, kRembEstimator);
|
||||
RateCounterFilter counter1(this, "sender_output");
|
||||
TraceBasedDeliveryFilter filter(this, "link_capacity");
|
||||
RateCounterFilter counter2(this, "receiver_input");
|
||||
PacketReceiver receiver(this, 0, GetParam(), true, true);
|
||||
ASSERT_TRUE(filter.Init(test::ResourcePath("verizon4g-downlink", "rx")));
|
||||
RunFor(22 * 60 * 1000);
|
||||
}
|
||||
@ -66,10 +88,9 @@ TEST_P(BweSimulation, Verizon4gDownlinkTest) {
|
||||
TEST_P(BweSimulation, Choke1000kbps500kbps1000kbps) {
|
||||
VerboseLogging(true);
|
||||
AdaptiveVideoSource source(0, 30, 300, 0, 0);
|
||||
PacketSender sender(this, &source, GetParam());
|
||||
PacketSender sender(this, &source, kRembEstimator);
|
||||
ChokeFilter filter(this);
|
||||
RateCounterFilter counter(this, "receiver_input");
|
||||
PacketReceiver receiver(this, 0, GetParam(), true, true);
|
||||
filter.SetCapacity(1000);
|
||||
filter.SetMaxDelay(500);
|
||||
RunFor(60 * 1000);
|
||||
@ -82,10 +103,9 @@ TEST_P(BweSimulation, Choke1000kbps500kbps1000kbps) {
|
||||
TEST_P(BweSimulation, PacerChoke1000kbps500kbps1000kbps) {
|
||||
VerboseLogging(true);
|
||||
PeriodicKeyFrameSource source(0, 30, 300, 0, 0, 1000);
|
||||
PacedVideoSender sender(this, &source, GetParam());
|
||||
PacedVideoSender sender(this, &source, kRembEstimator);
|
||||
ChokeFilter filter(this);
|
||||
RateCounterFilter counter(this, "receiver_input");
|
||||
PacketReceiver receiver(this, 0, GetParam(), true, true);
|
||||
filter.SetCapacity(1000);
|
||||
filter.SetMaxDelay(500);
|
||||
RunFor(60 * 1000);
|
||||
@ -98,10 +118,9 @@ TEST_P(BweSimulation, PacerChoke1000kbps500kbps1000kbps) {
|
||||
TEST_P(BweSimulation, PacerChoke10000kbps) {
|
||||
VerboseLogging(true);
|
||||
PeriodicKeyFrameSource source(0, 30, 300, 0, 0, 1000);
|
||||
PacedVideoSender sender(this, &source, GetParam());
|
||||
PacedVideoSender sender(this, &source, kRembEstimator);
|
||||
ChokeFilter filter(this);
|
||||
RateCounterFilter counter(this, "receiver_input");
|
||||
PacketReceiver receiver(this, 0, GetParam(), true, true);
|
||||
filter.SetCapacity(10000);
|
||||
filter.SetMaxDelay(500);
|
||||
RunFor(60 * 1000);
|
||||
@ -110,10 +129,9 @@ TEST_P(BweSimulation, PacerChoke10000kbps) {
|
||||
TEST_P(BweSimulation, PacerChoke200kbps30kbps200kbps) {
|
||||
VerboseLogging(true);
|
||||
PeriodicKeyFrameSource source(0, 30, 300, 0, 0, 1000);
|
||||
PacedVideoSender sender(this, &source, GetParam());
|
||||
PacedVideoSender sender(this, &source, kRembEstimator);
|
||||
ChokeFilter filter(this);
|
||||
RateCounterFilter counter(this, "receiver_input");
|
||||
PacketReceiver receiver(this, 0, GetParam(), true, true);
|
||||
filter.SetCapacity(200);
|
||||
filter.SetMaxDelay(500);
|
||||
RunFor(60 * 1000);
|
||||
@ -126,10 +144,9 @@ TEST_P(BweSimulation, PacerChoke200kbps30kbps200kbps) {
|
||||
TEST_P(BweSimulation, Choke200kbps30kbps200kbps) {
|
||||
VerboseLogging(true);
|
||||
AdaptiveVideoSource source(0, 30, 300, 0, 0);
|
||||
PacketSender sender(this, &source, GetParam());
|
||||
PacketSender sender(this, &source, kRembEstimator);
|
||||
ChokeFilter filter(this);
|
||||
RateCounterFilter counter(this, "receiver_input");
|
||||
PacketReceiver receiver(this, 0, GetParam(), true, true);
|
||||
filter.SetCapacity(200);
|
||||
filter.SetMaxDelay(500);
|
||||
RunFor(60 * 1000);
|
||||
@ -147,7 +164,6 @@ TEST_P(BweSimulation, GoogleWifiTrace3Mbps) {
|
||||
TraceBasedDeliveryFilter filter(this, "link_capacity");
|
||||
filter.SetMaxDelay(500);
|
||||
RateCounterFilter counter2(this, "receiver_input");
|
||||
PacketReceiver receiver(this, 0, GetParam(), true, true);
|
||||
ASSERT_TRUE(filter.Init(test::ResourcePath("google-wifi-3mbps", "rx")));
|
||||
RunFor(300 * 1000);
|
||||
}
|
||||
@ -160,12 +176,23 @@ TEST_P(BweSimulation, PacerGoogleWifiTrace3Mbps) {
|
||||
TraceBasedDeliveryFilter filter(this, "link_capacity");
|
||||
filter.SetMaxDelay(500);
|
||||
RateCounterFilter counter2(this, "receiver_input");
|
||||
PacketReceiver receiver(this, 0, GetParam(), true, true);
|
||||
ASSERT_TRUE(filter.Init(test::ResourcePath("google-wifi-3mbps", "rx")));
|
||||
RunFor(300 * 1000);
|
||||
}
|
||||
|
||||
TEST_P(BweSimulation, SelfFairnessTest) {
|
||||
class MultiFlowBweSimulation : public BweSimulation {
|
||||
public:
|
||||
MultiFlowBweSimulation() : BweSimulation() {}
|
||||
virtual ~MultiFlowBweSimulation() {}
|
||||
|
||||
private:
|
||||
DISALLOW_COPY_AND_ASSIGN(MultiFlowBweSimulation);
|
||||
};
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(VideoSendersTest, MultiFlowBweSimulation,
|
||||
::testing::Values(MakeMultiFlowBweTestConfig(3)));
|
||||
|
||||
TEST_P(MultiFlowBweSimulation, SelfFairnessTest) {
|
||||
VerboseLogging(true);
|
||||
const int kAllFlowIds[] = {0, 1, 2};
|
||||
const size_t kNumFlows = sizeof(kAllFlowIds) / sizeof(kAllFlowIds[0]);
|
||||
@ -176,7 +203,7 @@ TEST_P(BweSimulation, SelfFairnessTest) {
|
||||
// competing for the bandwidth.
|
||||
sources[i].reset(
|
||||
new AdaptiveVideoSource(kAllFlowIds[i], 30, 300, 0, i * 20000));
|
||||
senders[i].reset(new PacketSender(this, sources[i].get(), GetParam()));
|
||||
senders[i].reset(new PacketSender(this, sources[i].get(), kRembEstimator));
|
||||
}
|
||||
|
||||
ChokeFilter choke(this, CreateFlowIds(kAllFlowIds, kNumFlows));
|
||||
@ -191,16 +218,10 @@ TEST_P(BweSimulation, SelfFairnessTest) {
|
||||
RateCounterFilter total_utilization(
|
||||
this, CreateFlowIds(kAllFlowIds, kNumFlows), "total_utilization");
|
||||
|
||||
scoped_ptr<PacketReceiver> receivers[kNumFlows];
|
||||
for (size_t i = 0; i < kNumFlows; ++i) {
|
||||
receivers[i].reset(
|
||||
new PacketReceiver(this, kAllFlowIds[i], GetParam(), i == 0, false));
|
||||
}
|
||||
|
||||
RunFor(30 * 60 * 1000);
|
||||
}
|
||||
|
||||
TEST_P(BweSimulation, PacedSelfFairnessTest) {
|
||||
TEST_P(MultiFlowBweSimulation, PacedSelfFairnessTest) {
|
||||
VerboseLogging(true);
|
||||
const int kAllFlowIds[] = {0, 1, 2};
|
||||
const size_t kNumFlows = sizeof(kAllFlowIds) / sizeof(kAllFlowIds[0]);
|
||||
@ -212,7 +233,8 @@ TEST_P(BweSimulation, PacedSelfFairnessTest) {
|
||||
// competing for the bandwidth.
|
||||
sources[i].reset(new PeriodicKeyFrameSource(kAllFlowIds[i], 30, 300, 0,
|
||||
i * 20000, 1000));
|
||||
senders[i].reset(new PacedVideoSender(this, sources[i].get(), GetParam()));
|
||||
senders[i].reset(
|
||||
new PacedVideoSender(this, sources[i].get(), kRembEstimator));
|
||||
}
|
||||
|
||||
ChokeFilter choke(this, CreateFlowIds(kAllFlowIds, kNumFlows));
|
||||
@ -227,12 +249,6 @@ TEST_P(BweSimulation, PacedSelfFairnessTest) {
|
||||
RateCounterFilter total_utilization(
|
||||
this, CreateFlowIds(kAllFlowIds, kNumFlows), "total_utilization");
|
||||
|
||||
scoped_ptr<PacketReceiver> receivers[kNumFlows];
|
||||
for (size_t i = 0; i < kNumFlows; ++i) {
|
||||
receivers[i].reset(
|
||||
new PacketReceiver(this, kAllFlowIds[i], GetParam(), i == 0, false));
|
||||
}
|
||||
|
||||
RunFor(30 * 60 * 1000);
|
||||
}
|
||||
#endif // BWE_TEST_LOGGING_COMPILE_TIME_ENABLE
|
||||
|
||||
@ -20,39 +20,92 @@ using std::string;
|
||||
namespace webrtc {
|
||||
namespace testing {
|
||||
namespace bwe {
|
||||
enum Estimator { kAbsSendTime, kTransmissionOffset };
|
||||
|
||||
class DefaultBweTest : public BweTest,
|
||||
public ::testing::TestWithParam<BandwidthEstimatorType> {
|
||||
public:
|
||||
virtual ~DefaultBweTest() {}
|
||||
BweTestConfig::EstimatorConfig EstimatorConfigs(Estimator estimator,
|
||||
int flow_id) {
|
||||
static const RemoteBitrateEstimatorFactory factories[] = {
|
||||
RemoteBitrateEstimatorFactory(),
|
||||
AbsoluteSendTimeRemoteBitrateEstimatorFactory()
|
||||
};
|
||||
switch (estimator) {
|
||||
case kTransmissionOffset:
|
||||
return BweTestConfig::EstimatorConfig("TOF", flow_id, &factories[0],
|
||||
kAimdControl, kRembEstimator, false,
|
||||
false);
|
||||
case kAbsSendTime:
|
||||
return BweTestConfig::EstimatorConfig("AST", flow_id, &factories[1],
|
||||
kAimdControl, kRembEstimator, false,
|
||||
false);
|
||||
}
|
||||
assert(false);
|
||||
return BweTestConfig::EstimatorConfig();
|
||||
}
|
||||
|
||||
struct DefaultBweTestConfig {
|
||||
BweTestConfig bwe_test_config;
|
||||
size_t number_of_senders;
|
||||
};
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(VideoSendersTest,
|
||||
DefaultBweTest,
|
||||
::testing::Values(kRembEstimator,
|
||||
kFullSendSideEstimator));
|
||||
DefaultBweTestConfig MakeBweTestConfig(uint32_t sender_count,
|
||||
Estimator estimator) {
|
||||
DefaultBweTestConfig result;
|
||||
result.bwe_test_config.estimator_configs.push_back(
|
||||
EstimatorConfigs(estimator, 0));
|
||||
result.number_of_senders = sender_count;
|
||||
return result;
|
||||
}
|
||||
|
||||
class DefaultBweTest : public BweTest,
|
||||
public ::testing::TestWithParam<DefaultBweTestConfig> {
|
||||
public:
|
||||
virtual ~DefaultBweTest() {}
|
||||
|
||||
virtual void SetUp() {
|
||||
const DefaultBweTestConfig& config = GetParam();
|
||||
SetupTestFromConfig(config.bwe_test_config);
|
||||
for (size_t i = 0; i < config.number_of_senders; ++i) {
|
||||
sources_.push_back(new VideoSource(0, 30, 300, 0, 0));
|
||||
packet_senders_.push_back(
|
||||
new PacketSender(this, sources_.back(), kNullEstimator));
|
||||
}
|
||||
}
|
||||
|
||||
virtual void TearDown() {
|
||||
while (!packet_senders_.empty()) {
|
||||
delete packet_senders_.front();
|
||||
packet_senders_.pop_front();
|
||||
}
|
||||
while (!sources_.empty()) {
|
||||
delete sources_.front();
|
||||
sources_.pop_front();
|
||||
}
|
||||
}
|
||||
|
||||
protected:
|
||||
std::list<VideoSource*> sources_;
|
||||
std::list<PacketSender*> packet_senders_;
|
||||
};
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(VideoSendersTest, DefaultBweTest,
|
||||
::testing::Values(MakeBweTestConfig(1, kAbsSendTime),
|
||||
MakeBweTestConfig(3, kAbsSendTime),
|
||||
MakeBweTestConfig(1, kTransmissionOffset),
|
||||
MakeBweTestConfig(3, kTransmissionOffset)));
|
||||
|
||||
TEST_P(DefaultBweTest, UnlimitedSpeed) {
|
||||
VideoSource source(0, 30, 300, 0, 0);
|
||||
PacketSender sender(this, &source, GetParam());
|
||||
PacketReceiver receiver(this, 0, GetParam(), false, false);
|
||||
VerboseLogging(false);
|
||||
RunFor(10 * 60 * 1000);
|
||||
}
|
||||
|
||||
TEST_P(DefaultBweTest, DISABLED_SteadyLoss) {
|
||||
VideoSource source(0, 30, 300, 0, 0);
|
||||
PacketSender sender(this, &source, GetParam());
|
||||
LossFilter loss(this);
|
||||
PacketReceiver receiver(this, 0, GetParam(), false, false);
|
||||
loss.SetLoss(20.0);
|
||||
RunFor(10 * 60 * 1000);
|
||||
}
|
||||
|
||||
TEST_P(DefaultBweTest, IncreasingLoss1) {
|
||||
VideoSource source(0, 30, 300, 0, 0);
|
||||
PacketSender sender(this, &source, GetParam());
|
||||
LossFilter loss(this);
|
||||
PacketReceiver receiver(this, 0, GetParam(), false, false);
|
||||
for (int i = 0; i < 76; ++i) {
|
||||
loss.SetLoss(i);
|
||||
RunFor(5000);
|
||||
@ -60,19 +113,13 @@ TEST_P(DefaultBweTest, IncreasingLoss1) {
|
||||
}
|
||||
|
||||
TEST_P(DefaultBweTest, SteadyDelay) {
|
||||
VideoSource source(0, 30, 300, 0, 0);
|
||||
PacketSender sender(this, &source, GetParam());
|
||||
DelayFilter delay(this);
|
||||
PacketReceiver receiver(this, 0, GetParam(), false, false);
|
||||
delay.SetDelay(1000);
|
||||
RunFor(10 * 60 * 1000);
|
||||
}
|
||||
|
||||
TEST_P(DefaultBweTest, DISABLED_IncreasingDelay1) {
|
||||
VideoSource source(0, 30, 300, 0, 0);
|
||||
PacketSender sender(this, &source, GetParam());
|
||||
DelayFilter delay(this);
|
||||
PacketReceiver receiver(this, 0, GetParam(), false, false);
|
||||
RunFor(10 * 60 * 1000);
|
||||
for (int i = 0; i < 30 * 2; ++i) {
|
||||
delay.SetDelay(i);
|
||||
@ -82,11 +129,8 @@ TEST_P(DefaultBweTest, DISABLED_IncreasingDelay1) {
|
||||
}
|
||||
|
||||
TEST_P(DefaultBweTest, IncreasingDelay2) {
|
||||
VideoSource source(0, 30, 300, 0, 0);
|
||||
PacketSender sender(this, &source, GetParam());
|
||||
DelayFilter delay(this);
|
||||
RateCounterFilter counter(this);
|
||||
PacketReceiver receiver(this, 0, GetParam(), false, false);
|
||||
RunFor(1 * 60 * 1000);
|
||||
for (int i = 1; i < 51; ++i) {
|
||||
delay.SetDelay(10.0f * i);
|
||||
@ -97,10 +141,7 @@ TEST_P(DefaultBweTest, IncreasingDelay2) {
|
||||
}
|
||||
|
||||
TEST_P(DefaultBweTest, JumpyDelay1) {
|
||||
VideoSource source(0, 30, 300, 0, 0);
|
||||
PacketSender sender(this, &source, GetParam());
|
||||
DelayFilter delay(this);
|
||||
PacketReceiver receiver(this, 0, GetParam(), false, false);
|
||||
RunFor(10 * 60 * 1000);
|
||||
for (int i = 1; i < 200; ++i) {
|
||||
delay.SetDelay((10 * i) % 500);
|
||||
@ -113,20 +154,14 @@ TEST_P(DefaultBweTest, JumpyDelay1) {
|
||||
}
|
||||
|
||||
TEST_P(DefaultBweTest, SteadyJitter) {
|
||||
VideoSource source(0, 30, 300, 0, 0);
|
||||
PacketSender sender(this, &source, GetParam());
|
||||
JitterFilter jitter(this);
|
||||
RateCounterFilter counter(this);
|
||||
PacketReceiver receiver(this, 0, GetParam(), false, false);
|
||||
jitter.SetJitter(20);
|
||||
RunFor(2 * 60 * 1000);
|
||||
}
|
||||
|
||||
TEST_P(DefaultBweTest, IncreasingJitter1) {
|
||||
VideoSource source(0, 30, 300, 0, 0);
|
||||
PacketSender sender(this, &source, GetParam());
|
||||
JitterFilter jitter(this);
|
||||
PacketReceiver receiver(this, 0, GetParam(), false, false);
|
||||
for (int i = 0; i < 2 * 60 * 2; ++i) {
|
||||
jitter.SetJitter(i);
|
||||
RunFor(10 * 1000);
|
||||
@ -135,10 +170,7 @@ TEST_P(DefaultBweTest, IncreasingJitter1) {
|
||||
}
|
||||
|
||||
TEST_P(DefaultBweTest, IncreasingJitter2) {
|
||||
VideoSource source(0, 30, 300, 0, 0);
|
||||
PacketSender sender(this, &source, GetParam());
|
||||
JitterFilter jitter(this);
|
||||
PacketReceiver receiver(this, 0, GetParam(), false, false);
|
||||
RunFor(30 * 1000);
|
||||
for (int i = 1; i < 51; ++i) {
|
||||
jitter.SetJitter(10.0f * i);
|
||||
@ -149,19 +181,13 @@ TEST_P(DefaultBweTest, IncreasingJitter2) {
|
||||
}
|
||||
|
||||
TEST_P(DefaultBweTest, SteadyReorder) {
|
||||
VideoSource source(0, 30, 300, 0, 0);
|
||||
PacketSender sender(this, &source, GetParam());
|
||||
ReorderFilter reorder(this);
|
||||
PacketReceiver receiver(this, 0, GetParam(), false, false);
|
||||
reorder.SetReorder(20.0);
|
||||
RunFor(10 * 60 * 1000);
|
||||
}
|
||||
|
||||
TEST_P(DefaultBweTest, IncreasingReorder1) {
|
||||
VideoSource source(0, 30, 300, 0, 0);
|
||||
PacketSender sender(this, &source, GetParam());
|
||||
ReorderFilter reorder(this);
|
||||
PacketReceiver receiver(this, 0, GetParam(), false, false);
|
||||
for (int i = 0; i < 76; ++i) {
|
||||
reorder.SetReorder(i);
|
||||
RunFor(5000);
|
||||
@ -169,19 +195,13 @@ TEST_P(DefaultBweTest, IncreasingReorder1) {
|
||||
}
|
||||
|
||||
TEST_P(DefaultBweTest, DISABLED_SteadyChoke) {
|
||||
VideoSource source(0, 30, 300, 0, 0);
|
||||
PacketSender sender(this, &source, GetParam());
|
||||
ChokeFilter choke(this);
|
||||
PacketReceiver receiver(this, 0, GetParam(), false, false);
|
||||
choke.SetCapacity(140);
|
||||
RunFor(10 * 60 * 1000);
|
||||
}
|
||||
|
||||
TEST_P(DefaultBweTest, DISABLED_IncreasingChoke1) {
|
||||
VideoSource source(0, 30, 300, 0, 0);
|
||||
PacketSender sender(this, &source, GetParam());
|
||||
ChokeFilter choke(this);
|
||||
PacketReceiver receiver(this, 0, GetParam(), false, false);
|
||||
for (int i = 1200; i >= 100; i -= 100) {
|
||||
choke.SetCapacity(i);
|
||||
RunFor(5000);
|
||||
@ -189,10 +209,7 @@ TEST_P(DefaultBweTest, DISABLED_IncreasingChoke1) {
|
||||
}
|
||||
|
||||
TEST_P(DefaultBweTest, DISABLED_IncreasingChoke2) {
|
||||
VideoSource source(0, 30, 300, 0, 0);
|
||||
PacketSender sender(this, &source, GetParam());
|
||||
ChokeFilter choke(this);
|
||||
PacketReceiver receiver(this, 0, GetParam(), false, false);
|
||||
RunFor(60 * 1000);
|
||||
for (int i = 1200; i >= 100; i -= 20) {
|
||||
choke.SetCapacity(i);
|
||||
@ -201,12 +218,9 @@ TEST_P(DefaultBweTest, DISABLED_IncreasingChoke2) {
|
||||
}
|
||||
|
||||
TEST_P(DefaultBweTest, DISABLED_Multi1) {
|
||||
VideoSource source(0, 30, 300, 0, 0);
|
||||
PacketSender sender(this, &source, GetParam());
|
||||
DelayFilter delay(this);
|
||||
ChokeFilter choke(this);
|
||||
RateCounterFilter counter(this);
|
||||
PacketReceiver receiver(this, 0, GetParam(), false, false);
|
||||
choke.SetCapacity(1000);
|
||||
RunFor(1 * 60 * 1000);
|
||||
for (int i = 1; i < 51; ++i) {
|
||||
@ -219,12 +233,9 @@ TEST_P(DefaultBweTest, DISABLED_Multi1) {
|
||||
}
|
||||
|
||||
TEST_P(DefaultBweTest, Multi2) {
|
||||
VideoSource source(0, 30, 300, 0, 0);
|
||||
PacketSender sender(this, &source, GetParam());
|
||||
ChokeFilter choke(this);
|
||||
JitterFilter jitter(this);
|
||||
RateCounterFilter counter(this);
|
||||
PacketReceiver receiver(this, 0, GetParam(), false, false);
|
||||
choke.SetCapacity(2000);
|
||||
jitter.SetJitter(120);
|
||||
RunFor(5 * 60 * 1000);
|
||||
@ -232,13 +243,18 @@ TEST_P(DefaultBweTest, Multi2) {
|
||||
|
||||
// This test fixture is used to instantiate tests running with adaptive video
|
||||
// senders.
|
||||
class BweFeedbackTest
|
||||
: public BweTest,
|
||||
public ::testing::TestWithParam<BandwidthEstimatorType> {
|
||||
class BweFeedbackTest : public BweTest,
|
||||
public ::testing::TestWithParam<BweTestConfig> {
|
||||
public:
|
||||
BweFeedbackTest() : BweTest() {}
|
||||
virtual ~BweFeedbackTest() {}
|
||||
|
||||
virtual void SetUp() {
|
||||
BweTestConfig config;
|
||||
config.estimator_configs.push_back(EstimatorConfigs(kAbsSendTime, 0));
|
||||
SetupTestFromConfig(config);
|
||||
}
|
||||
|
||||
void PrintResults(double max_throughput_kbps, Stats<double> throughput_kbps,
|
||||
Stats<double> delay_ms) {
|
||||
double utilization = throughput_kbps.GetMean() / max_throughput_kbps;
|
||||
@ -264,24 +280,15 @@ class BweFeedbackTest
|
||||
false);
|
||||
}
|
||||
|
||||
protected:
|
||||
virtual void SetUp() OVERRIDE { BweTest::SetUp(); }
|
||||
|
||||
private:
|
||||
DISALLOW_COPY_AND_ASSIGN(BweFeedbackTest);
|
||||
};
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(VideoSendersTest,
|
||||
BweFeedbackTest,
|
||||
::testing::Values(kRembEstimator,
|
||||
kFullSendSideEstimator));
|
||||
|
||||
TEST_P(BweFeedbackTest, Choke1000kbps500kbps1000kbps) {
|
||||
TEST_F(BweFeedbackTest, Choke1000kbps500kbps1000kbps) {
|
||||
AdaptiveVideoSource source(0, 30, 300, 0, 0);
|
||||
PacketSender sender(this, &source, GetParam());
|
||||
PacketSender sender(this, &source, kRembEstimator);
|
||||
ChokeFilter filter(this);
|
||||
RateCounterFilter counter(this, "receiver_input");
|
||||
PacketReceiver receiver(this, 0, GetParam(), false, false);
|
||||
const int kHighCapacityKbps = 1000;
|
||||
const int kLowCapacityKbps = 500;
|
||||
filter.SetCapacity(kHighCapacityKbps);
|
||||
@ -295,12 +302,11 @@ TEST_P(BweFeedbackTest, Choke1000kbps500kbps1000kbps) {
|
||||
counter.GetBitrateStats(), filter.GetDelayStats());
|
||||
}
|
||||
|
||||
TEST_P(BweFeedbackTest, Choke200kbps30kbps200kbps) {
|
||||
TEST_F(BweFeedbackTest, Choke200kbps30kbps200kbps) {
|
||||
AdaptiveVideoSource source(0, 30, 300, 0, 0);
|
||||
PacketSender sender(this, &source, GetParam());
|
||||
PacketSender sender(this, &source, kRembEstimator);
|
||||
ChokeFilter filter(this);
|
||||
RateCounterFilter counter(this, "receiver_input");
|
||||
PacketReceiver receiver(this, 0, GetParam(), false, false);
|
||||
const int kHighCapacityKbps = 200;
|
||||
const int kLowCapacityKbps = 30;
|
||||
filter.SetCapacity(kHighCapacityKbps);
|
||||
@ -315,13 +321,12 @@ TEST_P(BweFeedbackTest, Choke200kbps30kbps200kbps) {
|
||||
counter.GetBitrateStats(), filter.GetDelayStats());
|
||||
}
|
||||
|
||||
TEST_P(BweFeedbackTest, Verizon4gDownlinkTest) {
|
||||
TEST_F(BweFeedbackTest, Verizon4gDownlinkTest) {
|
||||
AdaptiveVideoSource source(0, 30, 300, 0, 0);
|
||||
PacketSender sender(this, &source, GetParam());
|
||||
PacketSender sender(this, &source, kRembEstimator);
|
||||
RateCounterFilter counter1(this, "sender_output");
|
||||
TraceBasedDeliveryFilter filter(this, "link_capacity");
|
||||
RateCounterFilter counter2(this, "receiver_input");
|
||||
PacketReceiver receiver(this, 0, GetParam(), false, false);
|
||||
ASSERT_TRUE(filter.Init(test::ResourcePath("verizon4g-downlink", "rx")));
|
||||
RunFor(22 * 60 * 1000);
|
||||
PrintResults(filter.GetBitrateStats().GetMean(), counter2.GetBitrateStats(),
|
||||
@ -329,14 +334,13 @@ TEST_P(BweFeedbackTest, Verizon4gDownlinkTest) {
|
||||
}
|
||||
|
||||
// webrtc:3277
|
||||
TEST_P(BweFeedbackTest, DISABLED_GoogleWifiTrace3Mbps) {
|
||||
TEST_F(BweFeedbackTest, DISABLED_GoogleWifiTrace3Mbps) {
|
||||
AdaptiveVideoSource source(0, 30, 300, 0, 0);
|
||||
PacketSender sender(this, &source, GetParam());
|
||||
PacketSender sender(this, &source, kRembEstimator);
|
||||
RateCounterFilter counter1(this, "sender_output");
|
||||
TraceBasedDeliveryFilter filter(this, "link_capacity");
|
||||
filter.SetMaxDelay(500);
|
||||
RateCounterFilter counter2(this, "receiver_input");
|
||||
PacketReceiver receiver(this, 0, GetParam(), false, false);
|
||||
ASSERT_TRUE(filter.Init(test::ResourcePath("google-wifi-3mbps", "rx")));
|
||||
RunFor(300 * 1000);
|
||||
PrintResults(filter.GetBitrateStats().GetMean(), counter2.GetBitrateStats(),
|
||||
|
||||
@ -25,41 +25,81 @@ using std::vector;
|
||||
namespace webrtc {
|
||||
namespace testing {
|
||||
namespace bwe {
|
||||
class BweReceiver {
|
||||
public:
|
||||
explicit BweReceiver(int flow_id) : flow_id_(flow_id) {}
|
||||
virtual ~BweReceiver() {}
|
||||
|
||||
virtual void ReceivePacket(int64_t arrival_time_ms,
|
||||
size_t payload_size,
|
||||
const RTPHeader& header) {}
|
||||
class PacketReceiver {
|
||||
public:
|
||||
PacketReceiver(const string& test_name,
|
||||
const BweTestConfig::EstimatorConfig& config)
|
||||
: flow_id_(config.flow_id),
|
||||
debug_name_(config.debug_name),
|
||||
delay_log_prefix_(),
|
||||
last_delay_plot_ms_(0),
|
||||
plot_delay_(config.plot_delay),
|
||||
baseline_(BaseLineFileInterface::Create(test_name + "_" + debug_name_,
|
||||
config.update_baseline)) {
|
||||
// Setup the prefix strings used when logging.
|
||||
std::stringstream ss;
|
||||
ss << "Delay_" << config.flow_id << "#2";
|
||||
delay_log_prefix_ = ss.str();
|
||||
}
|
||||
virtual ~PacketReceiver() {}
|
||||
|
||||
virtual void ReceivePacket(const Packet& packet) {}
|
||||
|
||||
virtual FeedbackPacket* GetFeedback() { return NULL; }
|
||||
|
||||
protected:
|
||||
int flow_id_;
|
||||
};
|
||||
|
||||
int64_t GetAbsSendTimeInMs(uint32_t abs_send_time) {
|
||||
const int kInterArrivalShift = 26;
|
||||
const int kAbsSendTimeInterArrivalUpshift = 8;
|
||||
const double kTimestampToMs =
|
||||
1000.0 / static_cast<double>(1 << kInterArrivalShift);
|
||||
uint32_t timestamp = abs_send_time << kAbsSendTimeInterArrivalUpshift;
|
||||
return static_cast<int64_t>(timestamp) * kTimestampToMs;
|
||||
}
|
||||
|
||||
class SendSideBweReceiver : public BweReceiver {
|
||||
public:
|
||||
explicit SendSideBweReceiver(int flow_id) : BweReceiver(flow_id) {}
|
||||
virtual void ReceivePacket(int64_t arrival_time_ms,
|
||||
size_t payload_size,
|
||||
const RTPHeader& header) OVERRIDE {
|
||||
packet_feedback_vector_.push_back(PacketInfo(
|
||||
arrival_time_ms, GetAbsSendTimeInMs(header.extension.absoluteSendTime),
|
||||
header.sequenceNumber, payload_size));
|
||||
void LogStats() {
|
||||
BWE_TEST_LOGGING_CONTEXT(debug_name_);
|
||||
BWE_TEST_LOGGING_CONTEXT("Mean");
|
||||
stats_.Log("kbps");
|
||||
}
|
||||
|
||||
virtual FeedbackPacket* GetFeedback() OVERRIDE {
|
||||
void VerifyOrWriteBaseline() { EXPECT_TRUE(baseline_->VerifyOrWrite()); }
|
||||
|
||||
protected:
|
||||
static const int kDelayPlotIntervalMs = 100;
|
||||
|
||||
void LogDelay(int64_t arrival_time_ms, int64_t send_time_ms) {
|
||||
if (plot_delay_) {
|
||||
if (arrival_time_ms - last_delay_plot_ms_ > kDelayPlotIntervalMs) {
|
||||
BWE_TEST_LOGGING_PLOT(delay_log_prefix_, arrival_time_ms,
|
||||
arrival_time_ms - send_time_ms);
|
||||
last_delay_plot_ms_ = arrival_time_ms;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
const int flow_id_;
|
||||
const string debug_name_;
|
||||
string delay_log_prefix_;
|
||||
int64_t last_delay_plot_ms_;
|
||||
bool plot_delay_;
|
||||
scoped_ptr<BaseLineFileInterface> baseline_;
|
||||
Stats<double> stats_;
|
||||
|
||||
private:
|
||||
DISALLOW_IMPLICIT_CONSTRUCTORS(PacketReceiver);
|
||||
};
|
||||
|
||||
class SendSideBweReceiver : public PacketReceiver {
|
||||
public:
|
||||
SendSideBweReceiver(const string& test_name,
|
||||
const BweTestConfig::EstimatorConfig& config)
|
||||
: PacketReceiver(test_name, config) {}
|
||||
|
||||
virtual void EatPacket(const Packet& packet) {
|
||||
const MediaPacket& media_packet = static_cast<const MediaPacket&>(packet);
|
||||
// We're treating the send time (from previous filter) as the arrival
|
||||
// time once packet reaches the estimator.
|
||||
int64_t arrival_time_ms = (media_packet.send_time_us() + 500) / 1000;
|
||||
BWE_TEST_LOGGING_TIME(arrival_time_ms);
|
||||
LogDelay(arrival_time_ms, (media_packet.creation_time_us() + 500) / 1000);
|
||||
packet_feedback_vector_.push_back(PacketInfo(
|
||||
arrival_time_ms, media_packet.GetAbsSendTimeInMs(),
|
||||
media_packet.header().sequenceNumber, media_packet.payload_size()));
|
||||
}
|
||||
|
||||
virtual FeedbackPacket* GetFeedback() {
|
||||
FeedbackPacket* fb =
|
||||
new SendSideBweFeedback(flow_id_, 0, packet_feedback_vector_);
|
||||
packet_feedback_vector_.clear();
|
||||
@ -70,33 +110,44 @@ class SendSideBweReceiver : public BweReceiver {
|
||||
std::vector<PacketInfo> packet_feedback_vector_;
|
||||
};
|
||||
|
||||
class RembReceiver : public BweReceiver, public RemoteBitrateObserver {
|
||||
class RembReceiver : public PacketReceiver, public RemoteBitrateObserver {
|
||||
public:
|
||||
static const uint32_t kRemoteBitrateEstimatorMinBitrateBps = 30000;
|
||||
|
||||
RembReceiver(int flow_id, bool plot)
|
||||
: BweReceiver(flow_id),
|
||||
RembReceiver(const string& test_name,
|
||||
const BweTestConfig::EstimatorConfig& config)
|
||||
: PacketReceiver(test_name, config),
|
||||
estimate_log_prefix_(),
|
||||
plot_estimate_(plot),
|
||||
plot_estimate_(config.plot_estimate),
|
||||
clock_(0),
|
||||
recv_stats_(ReceiveStatistics::Create(&clock_)),
|
||||
latest_estimate_bps_(-1),
|
||||
estimator_(AbsoluteSendTimeRemoteBitrateEstimatorFactory().Create(
|
||||
estimator_(config.estimator_factory->Create(
|
||||
this,
|
||||
&clock_,
|
||||
kAimdControl,
|
||||
config.control_type,
|
||||
kRemoteBitrateEstimatorMinBitrateBps)) {
|
||||
assert(estimator_.get());
|
||||
assert(baseline_.get());
|
||||
std::stringstream ss;
|
||||
ss << "Estimate_" << flow_id_ << "#1";
|
||||
ss.str("");
|
||||
ss << "Estimate_" << config.flow_id << "#1";
|
||||
estimate_log_prefix_ = ss.str();
|
||||
// Default RTT in RemoteRateControl is 200 ms ; 50 ms is more realistic.
|
||||
estimator_->OnRttUpdate(50);
|
||||
}
|
||||
|
||||
virtual void ReceivePacket(int64_t arrival_time_ms,
|
||||
size_t payload_size,
|
||||
const RTPHeader& header) {
|
||||
recv_stats_->IncomingPacket(header, payload_size, false);
|
||||
virtual void ReceivePacket(const Packet& packet) {
|
||||
BWE_TEST_LOGGING_CONTEXT(debug_name_);
|
||||
assert(packet.GetPacketType() == Packet::kMediaPacket);
|
||||
const MediaPacket& media_packet = static_cast<const MediaPacket&>(packet);
|
||||
// We're treating the send time (from previous filter) as the arrival
|
||||
// time once packet reaches the estimator.
|
||||
int64_t arrival_time_ms = (media_packet.send_time_us() + 500) / 1000;
|
||||
BWE_TEST_LOGGING_TIME(arrival_time_ms);
|
||||
LogDelay(arrival_time_ms, (media_packet.creation_time_us() + 500) / 1000);
|
||||
recv_stats_->IncomingPacket(media_packet.header(),
|
||||
media_packet.payload_size(), false);
|
||||
|
||||
latest_estimate_bps_ = -1;
|
||||
|
||||
@ -106,14 +157,15 @@ class RembReceiver : public BweReceiver, public RemoteBitrateObserver {
|
||||
estimator_->Process();
|
||||
step_ms = std::max<int64_t>(estimator_->TimeUntilNextProcess(), 0);
|
||||
}
|
||||
estimator_->IncomingPacket(arrival_time_ms, payload_size, header);
|
||||
estimator_->IncomingPacket(arrival_time_ms, media_packet.payload_size(),
|
||||
media_packet.header());
|
||||
clock_.AdvanceTimeMilliseconds(arrival_time_ms -
|
||||
clock_.TimeInMilliseconds());
|
||||
ASSERT_TRUE(arrival_time_ms == clock_.TimeInMilliseconds());
|
||||
}
|
||||
|
||||
virtual FeedbackPacket* GetFeedback() {
|
||||
BWE_TEST_LOGGING_CONTEXT("Remb");
|
||||
BWE_TEST_LOGGING_CONTEXT(debug_name_);
|
||||
uint32_t estimated_bps = 0;
|
||||
RembFeedback* feedback = NULL;
|
||||
if (LatestEstimate(&estimated_bps)) {
|
||||
@ -124,8 +176,10 @@ class RembReceiver : public BweReceiver, public RemoteBitrateObserver {
|
||||
}
|
||||
feedback = new RembFeedback(flow_id_, clock_.TimeInMilliseconds(),
|
||||
estimated_bps, report_block);
|
||||
baseline_->Estimate(clock_.TimeInMilliseconds(), estimated_bps);
|
||||
|
||||
double estimated_kbps = static_cast<double>(estimated_bps) / 1000.0;
|
||||
stats_.Push(estimated_kbps);
|
||||
if (plot_estimate_) {
|
||||
BWE_TEST_LOGGING_PLOT(estimate_log_prefix_, clock_.TimeInMilliseconds(),
|
||||
estimated_kbps);
|
||||
@ -174,77 +228,22 @@ class RembReceiver : public BweReceiver, public RemoteBitrateObserver {
|
||||
DISALLOW_IMPLICIT_CONSTRUCTORS(RembReceiver);
|
||||
};
|
||||
|
||||
BweReceiver* CreateBweReceiver(BandwidthEstimatorType type,
|
||||
int flow_id,
|
||||
bool plot) {
|
||||
PacketReceiver* CreatePacketReceiver(
|
||||
BandwidthEstimatorType type,
|
||||
const string& test_name,
|
||||
const BweTestConfig::EstimatorConfig& config) {
|
||||
switch (type) {
|
||||
case kRembEstimator:
|
||||
return new RembReceiver(flow_id, plot);
|
||||
return new RembReceiver(test_name, config);
|
||||
case kFullSendSideEstimator:
|
||||
return new SendSideBweReceiver(flow_id);
|
||||
return new SendSideBweReceiver(test_name, config);
|
||||
case kNullEstimator:
|
||||
return new BweReceiver(flow_id);
|
||||
return new PacketReceiver(test_name, config);
|
||||
}
|
||||
assert(false);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
PacketReceiver::PacketReceiver(PacketProcessorListener* listener,
|
||||
int flow_id,
|
||||
BandwidthEstimatorType bwe_type,
|
||||
bool plot_delay,
|
||||
bool plot_bwe)
|
||||
: PacketProcessor(listener, flow_id, kReceiver),
|
||||
delay_log_prefix_(),
|
||||
last_delay_plot_ms_(0),
|
||||
plot_delay_(plot_delay),
|
||||
bwe_receiver_(CreateBweReceiver(bwe_type, flow_id, plot_bwe)) {
|
||||
// Setup the prefix strings used when logging.
|
||||
std::stringstream ss;
|
||||
ss << "Delay_" << flow_id << "#2";
|
||||
delay_log_prefix_ = ss.str();
|
||||
}
|
||||
|
||||
PacketReceiver::~PacketReceiver() {
|
||||
}
|
||||
|
||||
void PacketReceiver::RunFor(int64_t time_ms, Packets* in_out) {
|
||||
for (const auto* packet : *in_out) {
|
||||
// PacketReceivers are only associated with a single stream, and therefore
|
||||
// should only process a single flow id.
|
||||
// TODO(holmer): Break this out into a Demuxer which implements both
|
||||
// PacketProcessorListener and PacketProcessor.
|
||||
if (packet->flow_id() != *flow_ids().begin())
|
||||
continue;
|
||||
BWE_TEST_LOGGING_CONTEXT("Receiver");
|
||||
assert(packet->GetPacketType() == Packet::kMedia);
|
||||
const MediaPacket& media_packet = static_cast<const MediaPacket&>(*packet);
|
||||
// We're treating the send time (from previous filter) as the arrival
|
||||
// time once packet reaches the estimator.
|
||||
int64_t arrival_time_ms = (media_packet.send_time_us() + 500) / 1000;
|
||||
BWE_TEST_LOGGING_TIME(arrival_time_ms);
|
||||
PlotDelay(arrival_time_ms, (media_packet.creation_time_us() + 500) / 1000);
|
||||
|
||||
bwe_receiver_->ReceivePacket(arrival_time_ms, media_packet.payload_size(),
|
||||
media_packet.header());
|
||||
}
|
||||
}
|
||||
|
||||
FeedbackPacket* PacketReceiver::GetFeedback() {
|
||||
return bwe_receiver_->GetFeedback();
|
||||
}
|
||||
|
||||
void PacketReceiver::PlotDelay(int64_t arrival_time_ms, int64_t send_time_ms) {
|
||||
static const int kDelayPlotIntervalMs = 100;
|
||||
if (!plot_delay_)
|
||||
return;
|
||||
if (arrival_time_ms - last_delay_plot_ms_ > kDelayPlotIntervalMs) {
|
||||
BWE_TEST_LOGGING_PLOT(delay_log_prefix_, arrival_time_ms,
|
||||
arrival_time_ms - send_time_ms);
|
||||
last_delay_plot_ms_ = arrival_time_ms;
|
||||
}
|
||||
}
|
||||
|
||||
class PacketProcessorRunner {
|
||||
public:
|
||||
explicit PacketProcessorRunner(PacketProcessor* processor)
|
||||
@ -310,35 +309,51 @@ class PacketProcessorRunner {
|
||||
};
|
||||
|
||||
BweTest::BweTest()
|
||||
: run_time_ms_(0), time_now_ms_(-1), simulation_interval_ms_(-1) {
|
||||
: run_time_ms_(0),
|
||||
time_now_ms_(-1),
|
||||
simulation_interval_ms_(-1),
|
||||
estimators_(),
|
||||
processors_() {
|
||||
}
|
||||
|
||||
BweTest::~BweTest() {
|
||||
BWE_TEST_LOGGING_GLOBAL_ENABLE(true);
|
||||
for (const auto& estimator : estimators_) {
|
||||
estimator.second->VerifyOrWriteBaseline();
|
||||
estimator.second->LogStats();
|
||||
}
|
||||
BWE_TEST_LOGGING_GLOBAL_CONTEXT("");
|
||||
|
||||
for (const auto& estimator : estimators_) {
|
||||
delete estimator.second;
|
||||
}
|
||||
}
|
||||
|
||||
void BweTest::SetUp() {
|
||||
void BweTest::SetupTestFromConfig(const BweTestConfig& config) {
|
||||
const ::testing::TestInfo* const test_info =
|
||||
::testing::UnitTest::GetInstance()->current_test_info();
|
||||
string test_name =
|
||||
string(test_info->test_case_name()) + "_" + string(test_info->name());
|
||||
BWE_TEST_LOGGING_GLOBAL_CONTEXT(test_name);
|
||||
for (const auto& estimator_config : config.estimator_configs) {
|
||||
estimators_.insert(
|
||||
std::make_pair(estimator_config.flow_id,
|
||||
CreatePacketReceiver(estimator_config.bwe_type,
|
||||
test_name, estimator_config)));
|
||||
}
|
||||
BWE_TEST_LOGGING_GLOBAL_ENABLE(false);
|
||||
}
|
||||
|
||||
void BweTest::AddPacketProcessor(PacketProcessor* processor,
|
||||
ProcessorType processor_type) {
|
||||
void BweTest::AddPacketProcessor(PacketProcessor* processor, bool is_sender) {
|
||||
assert(processor);
|
||||
switch (processor_type) {
|
||||
case kSender:
|
||||
senders_.push_back(static_cast<PacketSender*>(processor));
|
||||
break;
|
||||
case kReceiver:
|
||||
receivers_.push_back(static_cast<PacketReceiver*>(processor));
|
||||
break;
|
||||
case kRegular:
|
||||
break;
|
||||
if (is_sender) {
|
||||
senders_.push_back(static_cast<PacketSender*>(processor));
|
||||
}
|
||||
processors_.push_back(PacketProcessorRunner(processor));
|
||||
for (const int& flow_id : processor->flow_ids()) {
|
||||
RTC_UNUSED(flow_id);
|
||||
assert(estimators_.count(flow_id) == 1);
|
||||
}
|
||||
}
|
||||
|
||||
void BweTest::RemovePacketProcessor(PacketProcessor* processor) {
|
||||
@ -356,8 +371,8 @@ void BweTest::VerboseLogging(bool enable) {
|
||||
BWE_TEST_LOGGING_GLOBAL_ENABLE(enable);
|
||||
}
|
||||
|
||||
void BweTest::GiveFeedbackToAffectedSenders(PacketReceiver* receiver) {
|
||||
FeedbackPacket* feedback = receiver->GetFeedback();
|
||||
void BweTest::GiveFeedbackToAffectedSenders(PacketReceiver* estimator) {
|
||||
FeedbackPacket* feedback = estimator->GetFeedback();
|
||||
if (feedback) {
|
||||
for (PacketSender* sender : senders_) {
|
||||
if (sender->flow_ids().find(feedback->flow_id()) !=
|
||||
@ -403,11 +418,15 @@ void BweTest::RunFor(int64_t time_ms) {
|
||||
ASSERT_TRUE(IsTimeSorted(packets));
|
||||
}
|
||||
|
||||
for (const auto* packet : packets)
|
||||
for (const Packet* packet : packets) {
|
||||
EstimatorMap::iterator est_it = estimators_.find(packet->flow_id());
|
||||
ASSERT_TRUE(est_it != estimators_.end());
|
||||
est_it->second->ReceivePacket(*packet);
|
||||
delete packet;
|
||||
}
|
||||
|
||||
for (const auto& receiver : receivers_) {
|
||||
GiveFeedbackToAffectedSenders(receiver);
|
||||
for (const auto& estimator : estimators_) {
|
||||
GiveFeedbackToAffectedSenders(estimator.second);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -18,68 +18,108 @@
|
||||
|
||||
namespace webrtc {
|
||||
|
||||
struct RemoteBitrateEstimatorFactory;
|
||||
|
||||
namespace testing {
|
||||
namespace bwe {
|
||||
|
||||
class BweReceiver;
|
||||
struct BweTestConfig {
|
||||
struct EstimatorConfig {
|
||||
EstimatorConfig()
|
||||
: debug_name(),
|
||||
flow_id(0),
|
||||
estimator_factory(NULL),
|
||||
control_type(kAimdControl),
|
||||
bwe_type(kRembEstimator),
|
||||
update_baseline(false),
|
||||
plot_delay(true),
|
||||
plot_estimate(true) {}
|
||||
EstimatorConfig(std::string debug_name,
|
||||
int flow_id,
|
||||
const RemoteBitrateEstimatorFactory* estimator_factory,
|
||||
BandwidthEstimatorType estimator_type,
|
||||
bool plot_delay,
|
||||
bool plot_estimate)
|
||||
: debug_name(debug_name),
|
||||
flow_id(flow_id),
|
||||
estimator_factory(estimator_factory),
|
||||
control_type(kAimdControl),
|
||||
bwe_type(kRembEstimator),
|
||||
update_baseline(false),
|
||||
plot_delay(plot_delay),
|
||||
plot_estimate(plot_estimate) {}
|
||||
EstimatorConfig(std::string debug_name,
|
||||
int flow_id,
|
||||
const RemoteBitrateEstimatorFactory* estimator_factory,
|
||||
RateControlType control_type,
|
||||
BandwidthEstimatorType estimator_type,
|
||||
bool plot_delay,
|
||||
bool plot_estimate)
|
||||
: debug_name(debug_name),
|
||||
flow_id(flow_id),
|
||||
estimator_factory(estimator_factory),
|
||||
control_type(control_type),
|
||||
bwe_type(estimator_type),
|
||||
update_baseline(false),
|
||||
plot_delay(plot_delay),
|
||||
plot_estimate(plot_estimate) {}
|
||||
EstimatorConfig(std::string debug_name,
|
||||
int flow_id,
|
||||
const RemoteBitrateEstimatorFactory* estimator_factory,
|
||||
RateControlType control_type,
|
||||
BandwidthEstimatorType estimator_type,
|
||||
bool update_baseline)
|
||||
: debug_name(debug_name),
|
||||
flow_id(flow_id),
|
||||
estimator_factory(estimator_factory),
|
||||
control_type(control_type),
|
||||
bwe_type(kRembEstimator),
|
||||
update_baseline(update_baseline),
|
||||
plot_delay(false),
|
||||
plot_estimate(false) {}
|
||||
std::string debug_name;
|
||||
int flow_id;
|
||||
const RemoteBitrateEstimatorFactory* estimator_factory;
|
||||
RateControlType control_type;
|
||||
BandwidthEstimatorType bwe_type;
|
||||
bool update_baseline;
|
||||
bool plot_delay;
|
||||
bool plot_estimate;
|
||||
};
|
||||
|
||||
std::vector<EstimatorConfig> estimator_configs;
|
||||
};
|
||||
|
||||
class PacketReceiver;
|
||||
class PacketProcessorRunner;
|
||||
|
||||
class PacketReceiver : public PacketProcessor {
|
||||
public:
|
||||
PacketReceiver(PacketProcessorListener* listener,
|
||||
int flow_id,
|
||||
BandwidthEstimatorType bwe_type,
|
||||
bool plot_delay,
|
||||
bool plot_bwe);
|
||||
~PacketReceiver();
|
||||
|
||||
// Implements PacketProcessor.
|
||||
virtual void RunFor(int64_t time_ms, Packets* in_out) OVERRIDE;
|
||||
|
||||
FeedbackPacket* GetFeedback();
|
||||
|
||||
void LogStats();
|
||||
|
||||
protected:
|
||||
void PlotDelay(int64_t arrival_time_ms, int64_t send_time_ms);
|
||||
|
||||
std::string delay_log_prefix_;
|
||||
int64_t last_delay_plot_ms_;
|
||||
bool plot_delay_;
|
||||
scoped_ptr<BweReceiver> bwe_receiver_;
|
||||
|
||||
private:
|
||||
DISALLOW_IMPLICIT_CONSTRUCTORS(PacketReceiver);
|
||||
};
|
||||
|
||||
class BweTest : public PacketProcessorListener {
|
||||
public:
|
||||
BweTest();
|
||||
virtual ~BweTest();
|
||||
|
||||
virtual void AddPacketProcessor(PacketProcessor* processor,
|
||||
ProcessorType type);
|
||||
virtual void AddPacketProcessor(PacketProcessor* processor, bool is_sender);
|
||||
virtual void RemovePacketProcessor(PacketProcessor* processor);
|
||||
|
||||
protected:
|
||||
virtual void SetUp();
|
||||
|
||||
void SetupTestFromConfig(const BweTestConfig& config);
|
||||
void VerboseLogging(bool enable);
|
||||
void RunFor(int64_t time_ms);
|
||||
std::string GetTestName() const;
|
||||
|
||||
private:
|
||||
typedef std::map<int, PacketReceiver*> EstimatorMap;
|
||||
|
||||
void FindPacketsToProcess(const FlowIds& flow_ids, Packets* in,
|
||||
Packets* out);
|
||||
void GiveFeedbackToAffectedSenders(PacketReceiver* receiver);
|
||||
void GiveFeedbackToAffectedSenders(PacketReceiver* estimator);
|
||||
|
||||
int64_t run_time_ms_;
|
||||
int64_t time_now_ms_;
|
||||
int64_t simulation_interval_ms_;
|
||||
EstimatorMap estimators_;
|
||||
Packets previous_packets_;
|
||||
std::vector<PacketSender*> senders_;
|
||||
std::vector<PacketReceiver*> receivers_;
|
||||
std::vector<PacketProcessorRunner> processors_;
|
||||
|
||||
DISALLOW_COPY_AND_ASSIGN(BweTest);
|
||||
|
||||
@ -163,6 +163,16 @@ MediaPacket::MediaPacket(int64_t send_time_us, uint32_t sequence_number)
|
||||
header_.sequenceNumber = sequence_number;
|
||||
}
|
||||
|
||||
int64_t MediaPacket::GetAbsSendTimeInMs() const {
|
||||
const int kInterArrivalShift = 26;
|
||||
const int kAbsSendTimeInterArrivalUpshift = 8;
|
||||
const double kTimestampToMs =
|
||||
1000.0 / static_cast<double>(1 << kInterArrivalShift);
|
||||
uint32_t timestamp = header_.extension.absoluteSendTime
|
||||
<< kAbsSendTimeInterArrivalUpshift;
|
||||
return static_cast<int64_t>(timestamp) * kTimestampToMs;
|
||||
}
|
||||
|
||||
void MediaPacket::SetAbsSendTimeMs(int64_t abs_send_time_ms) {
|
||||
header_.extension.hasAbsoluteSendTime = true;
|
||||
header_.extension.absoluteSendTime = ((static_cast<int64_t>(abs_send_time_ms *
|
||||
@ -198,30 +208,30 @@ bool IsTimeSorted(const Packets& packets) {
|
||||
}
|
||||
|
||||
PacketProcessor::PacketProcessor(PacketProcessorListener* listener,
|
||||
ProcessorType type)
|
||||
bool is_sender)
|
||||
: listener_(listener) {
|
||||
flow_ids_.insert(0);
|
||||
if (listener_) {
|
||||
listener_->AddPacketProcessor(this, type);
|
||||
listener_->AddPacketProcessor(this, is_sender);
|
||||
}
|
||||
}
|
||||
|
||||
PacketProcessor::PacketProcessor(PacketProcessorListener* listener,
|
||||
int flow_id,
|
||||
ProcessorType type)
|
||||
bool is_sender)
|
||||
: listener_(listener) {
|
||||
flow_ids_.insert(flow_id);
|
||||
if (listener_) {
|
||||
listener_->AddPacketProcessor(this, type);
|
||||
listener_->AddPacketProcessor(this, is_sender);
|
||||
}
|
||||
}
|
||||
|
||||
PacketProcessor::PacketProcessor(PacketProcessorListener* listener,
|
||||
const FlowIds& flow_ids,
|
||||
ProcessorType type)
|
||||
bool is_sender)
|
||||
: listener_(listener), flow_ids_(flow_ids) {
|
||||
if (listener_) {
|
||||
listener_->AddPacketProcessor(this, type);
|
||||
listener_->AddPacketProcessor(this, is_sender);
|
||||
}
|
||||
}
|
||||
|
||||
@ -232,26 +242,24 @@ PacketProcessor::~PacketProcessor() {
|
||||
}
|
||||
|
||||
RateCounterFilter::RateCounterFilter(PacketProcessorListener* listener)
|
||||
: PacketProcessor(listener, kRegular),
|
||||
: PacketProcessor(listener, false),
|
||||
rate_counter_(new RateCounter()),
|
||||
packets_per_second_stats_(),
|
||||
kbps_stats_(),
|
||||
name_("") {
|
||||
}
|
||||
name_("") {}
|
||||
|
||||
RateCounterFilter::RateCounterFilter(PacketProcessorListener* listener,
|
||||
const std::string& name)
|
||||
: PacketProcessor(listener, kRegular),
|
||||
: PacketProcessor(listener, false),
|
||||
rate_counter_(new RateCounter()),
|
||||
packets_per_second_stats_(),
|
||||
kbps_stats_(),
|
||||
name_(name) {
|
||||
}
|
||||
name_(name) {}
|
||||
|
||||
RateCounterFilter::RateCounterFilter(PacketProcessorListener* listener,
|
||||
const FlowIds& flow_ids,
|
||||
const std::string& name)
|
||||
: PacketProcessor(listener, flow_ids, kRegular),
|
||||
: PacketProcessor(listener, flow_ids, false),
|
||||
rate_counter_(new RateCounter()),
|
||||
packets_per_second_stats_(),
|
||||
kbps_stats_(),
|
||||
@ -302,7 +310,7 @@ void RateCounterFilter::RunFor(int64_t /*time_ms*/, Packets* in_out) {
|
||||
}
|
||||
|
||||
LossFilter::LossFilter(PacketProcessorListener* listener)
|
||||
: PacketProcessor(listener, kRegular),
|
||||
: PacketProcessor(listener, false),
|
||||
random_(0x12345678),
|
||||
loss_fraction_(0.0f) {
|
||||
}
|
||||
@ -328,7 +336,9 @@ void LossFilter::RunFor(int64_t /*time_ms*/, Packets* in_out) {
|
||||
}
|
||||
|
||||
DelayFilter::DelayFilter(PacketProcessorListener* listener)
|
||||
: PacketProcessor(listener, kRegular), delay_us_(0), last_send_time_us_(0) {
|
||||
: PacketProcessor(listener, false),
|
||||
delay_us_(0),
|
||||
last_send_time_us_(0) {
|
||||
}
|
||||
|
||||
void DelayFilter::SetDelay(int64_t delay_ms) {
|
||||
@ -348,7 +358,7 @@ void DelayFilter::RunFor(int64_t /*time_ms*/, Packets* in_out) {
|
||||
}
|
||||
|
||||
JitterFilter::JitterFilter(PacketProcessorListener* listener)
|
||||
: PacketProcessor(listener, kRegular),
|
||||
: PacketProcessor(listener, false),
|
||||
random_(0x89674523),
|
||||
stddev_jitter_us_(0),
|
||||
last_send_time_us_(0) {
|
||||
@ -373,7 +383,7 @@ void JitterFilter::RunFor(int64_t /*time_ms*/, Packets* in_out) {
|
||||
}
|
||||
|
||||
ReorderFilter::ReorderFilter(PacketProcessorListener* listener)
|
||||
: PacketProcessor(listener, kRegular),
|
||||
: PacketProcessor(listener, false),
|
||||
random_(0x27452389),
|
||||
reorder_fraction_(0.0f) {
|
||||
}
|
||||
@ -405,7 +415,7 @@ void ReorderFilter::RunFor(int64_t /*time_ms*/, Packets* in_out) {
|
||||
}
|
||||
|
||||
ChokeFilter::ChokeFilter(PacketProcessorListener* listener)
|
||||
: PacketProcessor(listener, kRegular),
|
||||
: PacketProcessor(listener, false),
|
||||
kbps_(1200),
|
||||
last_send_time_us_(0),
|
||||
delay_cap_helper_(new DelayCapHelper()) {
|
||||
@ -413,7 +423,7 @@ ChokeFilter::ChokeFilter(PacketProcessorListener* listener)
|
||||
|
||||
ChokeFilter::ChokeFilter(PacketProcessorListener* listener,
|
||||
const FlowIds& flow_ids)
|
||||
: PacketProcessor(listener, flow_ids, kRegular),
|
||||
: PacketProcessor(listener, flow_ids, false),
|
||||
kbps_(1200),
|
||||
last_send_time_us_(0),
|
||||
delay_cap_helper_(new DelayCapHelper()) {
|
||||
@ -457,7 +467,7 @@ Stats<double> ChokeFilter::GetDelayStats() const {
|
||||
|
||||
TraceBasedDeliveryFilter::TraceBasedDeliveryFilter(
|
||||
PacketProcessorListener* listener)
|
||||
: PacketProcessor(listener, kRegular),
|
||||
: PacketProcessor(listener, false),
|
||||
current_offset_us_(0),
|
||||
delivery_times_us_(),
|
||||
next_delivery_it_(),
|
||||
@ -466,13 +476,12 @@ TraceBasedDeliveryFilter::TraceBasedDeliveryFilter(
|
||||
name_(""),
|
||||
delay_cap_helper_(new DelayCapHelper()),
|
||||
packets_per_second_stats_(),
|
||||
kbps_stats_() {
|
||||
}
|
||||
kbps_stats_() {}
|
||||
|
||||
TraceBasedDeliveryFilter::TraceBasedDeliveryFilter(
|
||||
PacketProcessorListener* listener,
|
||||
const std::string& name)
|
||||
: PacketProcessor(listener, kRegular),
|
||||
: PacketProcessor(listener, false),
|
||||
current_offset_us_(0),
|
||||
delivery_times_us_(),
|
||||
next_delivery_it_(),
|
||||
@ -481,8 +490,7 @@ TraceBasedDeliveryFilter::TraceBasedDeliveryFilter(
|
||||
name_(name),
|
||||
delay_cap_helper_(new DelayCapHelper()),
|
||||
packets_per_second_stats_(),
|
||||
kbps_stats_() {
|
||||
}
|
||||
kbps_stats_() {}
|
||||
|
||||
TraceBasedDeliveryFilter::~TraceBasedDeliveryFilter() {
|
||||
}
|
||||
@ -807,7 +815,7 @@ SendSideBwe* CreateEstimator(BandwidthEstimatorType estimator,
|
||||
PacketSender::PacketSender(PacketProcessorListener* listener,
|
||||
VideoSource* source,
|
||||
BandwidthEstimatorType estimator)
|
||||
: PacketProcessor(listener, source->flow_id(), kSender),
|
||||
: PacketProcessor(listener, source->flow_id(), true),
|
||||
// For Packet::send_time_us() to be comparable with timestamps from
|
||||
// clock_, the clock of the PacketSender and the Source must be aligned.
|
||||
// We assume that both start at time 0.
|
||||
|
||||
@ -162,7 +162,7 @@ class Random {
|
||||
|
||||
class Packet {
|
||||
public:
|
||||
enum Type { kMedia, kFeedback };
|
||||
enum Type { kMediaPacket, kFeedbackPacket };
|
||||
|
||||
Packet();
|
||||
Packet(int flow_id, int64_t send_time_us, size_t payload_size);
|
||||
@ -197,7 +197,7 @@ class MediaPacket : public Packet {
|
||||
int64_t GetAbsSendTimeInMs() const;
|
||||
void SetAbsSendTimeMs(int64_t abs_send_time_ms);
|
||||
const RTPHeader& header() const { return header_; }
|
||||
virtual Packet::Type GetPacketType() const { return kMedia; }
|
||||
virtual Packet::Type GetPacketType() const { return kMediaPacket; }
|
||||
|
||||
private:
|
||||
RTPHeader header_;
|
||||
@ -209,7 +209,7 @@ class FeedbackPacket : public Packet {
|
||||
: Packet(flow_id, send_time_us, 0) {}
|
||||
virtual ~FeedbackPacket() {}
|
||||
|
||||
virtual Packet::Type GetPacketType() const { return kFeedback; }
|
||||
virtual Packet::Type GetPacketType() const { return kFeedbackPacket; }
|
||||
};
|
||||
|
||||
class RembFeedback : public FeedbackPacket {
|
||||
@ -252,26 +252,23 @@ bool IsTimeSorted(const Packets& packets);
|
||||
|
||||
class PacketProcessor;
|
||||
|
||||
enum ProcessorType { kSender, kReceiver, kRegular };
|
||||
|
||||
class PacketProcessorListener {
|
||||
public:
|
||||
virtual ~PacketProcessorListener() {}
|
||||
|
||||
virtual void AddPacketProcessor(PacketProcessor* processor,
|
||||
ProcessorType type) = 0;
|
||||
bool is_sender) = 0;
|
||||
virtual void RemovePacketProcessor(PacketProcessor* processor) = 0;
|
||||
};
|
||||
|
||||
class PacketProcessor {
|
||||
public:
|
||||
PacketProcessor(PacketProcessorListener* listener, ProcessorType type);
|
||||
PacketProcessor(PacketProcessorListener* listener, bool is_sender);
|
||||
PacketProcessor(PacketProcessorListener* listener,
|
||||
int flow_id,
|
||||
ProcessorType type);
|
||||
PacketProcessor(PacketProcessorListener* listener,
|
||||
const FlowIds& flow_ids,
|
||||
ProcessorType type);
|
||||
bool is_sender);
|
||||
PacketProcessor(PacketProcessorListener* listener, const FlowIds& flow_ids,
|
||||
bool is_sender);
|
||||
virtual ~PacketProcessor();
|
||||
|
||||
// Called after each simulation batch to allow the processor to plot any
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user