admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Simplifies transport overhead mechanism in Scenario test framework.

Browse Source 
This changes the behavior for adding virtual transport overhead so it
doesn't change the size of the actual payload buffer, only the
calculated packet size.

Bug: webrtc:9883
Change-Id: I6e24598378c4dd6a591d36ca3b162e933ff4ef7c
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/164523
Commit-Queue: Sebastian Jansson <srte@webrtc.org>
Reviewed-by: Artem Titov <titovartem@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#30298}
This commit is contained in:
Sebastian Jansson 2020-01-17 11:47:35 +01:00 committed by Commit Bot
parent 2d31aea481
commit c9f42ad909
11 changed files with 26 additions and 38 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
api/test/network_emulation/network_emulation_interfaces.cc
View File

@ -12,19 +12,23 @@
namespace webrtc {
namespace {
constexpr size_t kIPv4HeaderSize = 20;
constexpr size_t kIPv6HeaderSize = 40;
constexpr int kIPv4HeaderSize = 20;
constexpr int kIPv6HeaderSize = 40;
constexpr int kUdpHeaderSize = 8;
int IpHeaderSize(const rtc::SocketAddress& address) {
return (address.family() == AF_INET) ? kIPv4HeaderSize : kIPv6HeaderSize;
}
} // namespace
EmulatedIpPacket::EmulatedIpPacket(const rtc::SocketAddress& from,
const rtc::SocketAddress& to,
rtc::CopyOnWriteBuffer data,
Timestamp arrival_time)
Timestamp arrival_time,
uint16_t application_overhead)
: from(from),
to(to),
data(data),
ip_header_size((to.family() == AF_INET) ? kIPv4HeaderSize
: kIPv6HeaderSize),
headers_size(IpHeaderSize(to) + application_overhead + kUdpHeaderSize),
arrival_time(arrival_time) {
RTC_DCHECK(to.family() == AF_INET || to.family() == AF_INET6);
}

11
api/test/network_emulation/network_emulation_interfaces.h
View File

@ -22,12 +22,11 @@ namespace webrtc {
struct EmulatedIpPacket {
public:
static constexpr int kUdpHeaderSize = 8;
EmulatedIpPacket(const rtc::SocketAddress& from,
const rtc::SocketAddress& to,
rtc::CopyOnWriteBuffer data,
Timestamp arrival_time);
Timestamp arrival_time,
uint16_t application_overhead = 0);
~EmulatedIpPacket() = default;
// This object is not copyable or assignable.
EmulatedIpPacket(const EmulatedIpPacket&) = delete;
@ -39,14 +38,12 @@ struct EmulatedIpPacket {
size_t size() const { return data.size(); }
const uint8_t* cdata() const { return data.cdata(); }
size_t ip_packet_size() const {
return size() + kUdpHeaderSize + ip_header_size;
}
size_t ip_packet_size() const { return size() + headers_size; }
rtc::SocketAddress from;
rtc::SocketAddress to;
// Holds the UDP payload.
rtc::CopyOnWriteBuffer data;
int ip_header_size;
uint16_t headers_size;
Timestamp arrival_time;
};

7
modules/congestion_controller/bbr/bbr_network_controller_unittest.cc
View File

@ -132,9 +132,10 @@ TEST_F(BbrNetworkControllerTest, UpdatesTargetSendRate) {
auto ret_net = s.CreateMutableSimulationNode(
[](NetworkSimulationConfig* c) { c->delay = TimeDelta::ms(100); });
auto* client = s.CreateClient("send", config);
auto routes = s.CreateRoutes(client, {send_net->node()},
const DataSize kOverhead = DataSize::bytes(38); // IPV4 + UDP + SRTP
auto routes = s.CreateRoutes(client, {send_net->node()}, kOverhead,
s.CreateClient("recv", CallClientConfig()),
{ret_net->node()});
{ret_net->node()}, kOverhead);
s.CreateVideoStream(routes->forward(), VideoStreamConfig());
s.RunFor(TimeDelta::seconds(25));
@ -156,7 +157,7 @@ TEST_F(BbrNetworkControllerTest, UpdatesTargetSendRate) {
[](NetworkSimulationConfig* c) { c->delay = TimeDelta::ms(200); });
s.RunFor(TimeDelta::seconds(35));
EXPECT_NEAR(client->send_bandwidth().kbps(), 180, 50);
EXPECT_NEAR(client->send_bandwidth().kbps(), 170, 50);
}
} // namespace test

2
modules/congestion_controller/goog_cc/goog_cc_network_control_unittest.cc
View File

@ -410,7 +410,7 @@ TEST_F(GoogCcNetworkControllerTest, LimitsToFloorIfRttIsHighInTrial) {
// This will cause the RTT to be large for a while.
s.TriggerPacketBurst({send_net}, kBloatPacketCount, kBloatPacketSize.bytes());
// Wait to allow the high RTT to be detected and acted upon.
s.RunFor(TimeDelta::seconds(4));
s.RunFor(TimeDelta::seconds(6));
// By now the target rate should have dropped to the minimum configured rate.
EXPECT_NEAR(client->target_rate().kbps(), kBandwidthFloor.kbps(), 5);
}

2
modules/congestion_controller/pcc/pcc_network_controller_unittest.cc
View File

@ -109,7 +109,7 @@ TEST(PccNetworkControllerTest, UpdatesTargetSendRate) {
ret_net->UpdateConfig(
[](NetworkSimulationConfig* c) { c->delay = TimeDelta::ms(200); });
s.RunFor(TimeDelta::seconds(35));
EXPECT_NEAR(client->target_rate().kbps(), 180, 40);
EXPECT_NEAR(client->target_rate().kbps(), 170, 50);
}
} // namespace test

6
test/scenario/call_client.cc
View File

@ -263,12 +263,6 @@ DataRate CallClient::padding_rate() const {
}
void CallClient::OnPacketReceived(EmulatedIpPacket packet) {
// Removes added overhead before delivering packet to sender.
size_t size =
packet.data.size() - route_overhead_.at(packet.to.ipaddr()).bytes();
RTC_DCHECK_GE(size, 0);
packet.data.SetSize(size);
MediaType media_type = MediaType::ANY;
if (!RtpHeaderParser::IsRtcp(packet.cdata(), packet.data.size())) {
auto ssrc = RtpHeaderParser::GetSsrc(packet.cdata(), packet.data.size());

3
test/scenario/call_client.h
View File

@ -141,9 +141,6 @@ class CallClient : public EmulatedNetworkReceiverInterface {
std::unique_ptr<NetworkNodeTransport> transport_;
std::unique_ptr<RtpHeaderParser> const header_parser_;
// Stores the configured overhead per known destination endpoint. This is used
// to subtract the overhead before processing.
std::map<rtc::IPAddress, DataSize> route_overhead_;
int next_video_ssrc_index_ = 0;
int next_video_local_ssrc_index_ = 0;
int next_rtx_ssrc_index_ = 0;

11
test/scenario/network_node.cc
View File

@ -89,11 +89,10 @@ bool NetworkNodeTransport::SendRtp(const uint8_t* packet,
rtc::CritScope crit(&crit_sect_);
if (!send_net_)
return false;
rtc::CopyOnWriteBuffer buffer(packet, length,
length + packet_overhead_.bytes());
buffer.SetSize(length + packet_overhead_.bytes());
rtc::CopyOnWriteBuffer buffer(packet, length);
send_net_->OnPacketReceived(
EmulatedIpPacket(local_address_, receiver_address_, buffer, send_time));
EmulatedIpPacket(local_address_, receiver_address_, buffer, send_time,
packet_overhead_.bytes()));
return true;
}
@ -101,11 +100,11 @@ bool NetworkNodeTransport::SendRtcp(const uint8_t* packet, size_t length) {
rtc::CopyOnWriteBuffer buffer(packet, length);
Timestamp send_time = sender_clock_->CurrentTime();
rtc::CritScope crit(&crit_sect_);
buffer.SetSize(length + packet_overhead_.bytes());
if (!send_net_)
return false;
send_net_->OnPacketReceived(
EmulatedIpPacket(local_address_, receiver_address_, buffer, send_time));
EmulatedIpPacket(local_address_, receiver_address_, buffer, send_time,
packet_overhead_.bytes()));
return true;
}

1
test/scenario/scenario.cc
View File

@ -166,7 +166,6 @@ void Scenario::ChangeRoute(std::pair<CallClient*, CallClient*> clients,
std::vector<EmulatedNetworkNode*> over_nodes,
DataSize overhead) {
rtc::IPAddress route_ip(next_route_id_++);
clients.second->route_overhead_.insert({route_ip, overhead});
EmulatedNetworkNode::CreateRoute(route_ip, over_nodes, clients.second);
clients.first->transport_->Connect(over_nodes.front(), route_ip, overhead);
}

5
test/scenario/scenario_config.h
View File

@ -28,9 +28,6 @@
namespace webrtc {
namespace test {
struct PacketOverhead {
static constexpr size_t kIpv4 = 20;
static constexpr size_t kIpv6 = 40;
static constexpr size_t kUdp = 8;
static constexpr size_t kSrtp = 10;
static constexpr size_t kStun = 4;
// TURN messages can be sent either with or without an establieshed channel.
@ -38,7 +35,7 @@ struct PacketOverhead {
// significantly more overhead.
static constexpr size_t kTurnChannelMessage = 4;
static constexpr size_t kTurnIndicationMessage = 36;
static constexpr size_t kDefault = kIpv4 + kUdp + kSrtp;
static constexpr size_t kDefault = kSrtp;
};
struct TransportControllerConfig {
struct Rates {

2
test/scenario/stats_collection_unittest.cc
View File

@ -78,7 +78,7 @@ TEST(ScenarioAnalyzerTest, PsnrIsLowWhenNetworkIsBad) {
EXPECT_NEAR(stats.call.stats().target_rate.Mean().kbps(), 75, 50);
EXPECT_NEAR(stats.video_send.stats().media_bitrate.Mean().kbps(), 100, 50);
EXPECT_NEAR(stats.video_receive.stats().resolution.Mean(), 180, 10);
EXPECT_NEAR(stats.audio_receive.stats().jitter_buffer.Mean().ms(), 150, 130);
EXPECT_NEAR(stats.audio_receive.stats().jitter_buffer.Mean().ms(), 200, 150);
}
TEST(ScenarioAnalyzerTest, CountsCapturedButNotRendered) {