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

Switch routing from dest endpoint id to dest ip in network emulation layer

Browse Source 
Bug: webrtc:10138
Change-Id: I8659777820ec7244c1435d71504b0c01fb438192
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/130103
Reviewed-by: Yves Gerey <yvesg@google.com>
Reviewed-by: Sebastian Jansson <srte@webrtc.org>
Commit-Queue: Artem Titov <titovartem@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#27386}
This commit is contained in:
Artem Titov
2019-04-01 11:01:16 +02:00
committed by Commit Bot
parent 359fe33163
commit 4cd433ed5f
11 changed files with 107 additions and 111 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
test/scenario/call_client.cc
View File

@ -195,10 +195,10 @@ Call::Stats CallClient::GetStats() {
void CallClient::OnPacketReceived(EmulatedIpPacket packet) { void CallClient::OnPacketReceived(EmulatedIpPacket packet) {
// Removes added overhead before delivering packet to sender. // Removes added overhead before delivering packet to sender.
RTC_DCHECK_GE(packet.data.size(), size_t size =
route_overhead_.at(packet.dest_endpoint_id).bytes()); packet.data.size() - route_overhead_.at(packet.to.ipaddr()).bytes();
packet.data.SetSize(packet.data.size() - RTC_DCHECK_GE(size, 0);
route_overhead_.at(packet.dest_endpoint_id).bytes()); packet.data.SetSize(size);
MediaType media_type = MediaType::ANY; MediaType media_type = MediaType::ANY;
if (!RtpHeaderParser::IsRtcp(packet.cdata(), packet.data.size())) { if (!RtpHeaderParser::IsRtcp(packet.cdata(), packet.data.size())) {

2
test/scenario/call_client.h
View File

@ -112,7 +112,7 @@ class CallClient : public EmulatedNetworkReceiverInterface {
std::unique_ptr<FecControllerFactoryInterface> fec_controller_factory_; std::unique_ptr<FecControllerFactoryInterface> fec_controller_factory_;
// Stores the configured overhead per known destination endpoint. This is used // Stores the configured overhead per known destination endpoint. This is used
// to subtract the overhead before processing. // to subtract the overhead before processing.
std::map<uint64_t, DataSize> route_overhead_; std::map<rtc::IPAddress, DataSize> route_overhead_;
int next_video_ssrc_index_ = 0; int next_video_ssrc_index_ = 0;
int next_video_local_ssrc_index_ = 0; int next_video_local_ssrc_index_ = 0;
int next_rtx_ssrc_index_ = 0; int next_rtx_ssrc_index_ = 0;

56
test/scenario/network/network_emulation.cc
View File

@ -21,12 +21,10 @@ namespace webrtc {
EmulatedIpPacket::EmulatedIpPacket(const rtc::SocketAddress& from, EmulatedIpPacket::EmulatedIpPacket(const rtc::SocketAddress& from,
const rtc::SocketAddress& to, const rtc::SocketAddress& to,
uint64_t dest_endpoint_id,
rtc::CopyOnWriteBuffer data, rtc::CopyOnWriteBuffer data,
Timestamp arrival_time) Timestamp arrival_time)
: from(from), : from(from),
to(to), to(to),
dest_endpoint_id(dest_endpoint_id),
data(data), data(data),
arrival_time(arrival_time) {} arrival_time(arrival_time) {}
EmulatedIpPacket::~EmulatedIpPacket() = default; EmulatedIpPacket::~EmulatedIpPacket() = default;
@ -34,19 +32,19 @@ EmulatedIpPacket::EmulatedIpPacket(EmulatedIpPacket&&) = default;
EmulatedIpPacket& EmulatedIpPacket::operator=(EmulatedIpPacket&&) = default; EmulatedIpPacket& EmulatedIpPacket::operator=(EmulatedIpPacket&&) = default;
void EmulatedNetworkNode::CreateRoute( void EmulatedNetworkNode::CreateRoute(
uint64_t receiver_id, rtc::IPAddress receiver_ip,
std::vector<EmulatedNetworkNode*> nodes, std::vector<EmulatedNetworkNode*> nodes,
EmulatedNetworkReceiverInterface* receiver) { EmulatedNetworkReceiverInterface* receiver) {
RTC_CHECK(!nodes.empty()); RTC_CHECK(!nodes.empty());
for (size_t i = 0; i + 1 < nodes.size(); ++i) for (size_t i = 0; i + 1 < nodes.size(); ++i)
nodes[i]->SetReceiver(receiver_id, nodes[i + 1]); nodes[i]->SetReceiver(receiver_ip, nodes[i + 1]);
nodes.back()->SetReceiver(receiver_id, receiver); nodes.back()->SetReceiver(receiver_ip, receiver);
} }
void EmulatedNetworkNode::ClearRoute(uint64_t receiver_id, void EmulatedNetworkNode::ClearRoute(rtc::IPAddress receiver_ip,
std::vector<EmulatedNetworkNode*> nodes) { std::vector<EmulatedNetworkNode*> nodes) {
for (EmulatedNetworkNode* node : nodes) for (EmulatedNetworkNode* node : nodes)
node->RemoveReceiver(receiver_id); node->RemoveReceiver(receiver_ip);
} }
EmulatedNetworkNode::EmulatedNetworkNode( EmulatedNetworkNode::EmulatedNetworkNode(
@ -57,7 +55,7 @@ EmulatedNetworkNode::~EmulatedNetworkNode() = default;
void EmulatedNetworkNode::OnPacketReceived(EmulatedIpPacket packet) { void EmulatedNetworkNode::OnPacketReceived(EmulatedIpPacket packet) {
rtc::CritScope crit(&lock_); rtc::CritScope crit(&lock_);
if (routing_.find(packet.dest_endpoint_id) == routing_.end()) { if (routing_.find(packet.to.ipaddr()) == routing_.end()) {
return; return;
} }
uint64_t packet_id = next_packet_id_++; uint64_t packet_id = next_packet_id_++;
@ -92,7 +90,7 @@ void EmulatedNetworkNode::Process(Timestamp at_time) {
} }
RTC_CHECK(packet); RTC_CHECK(packet);
RTC_DCHECK(!packet->removed); RTC_DCHECK(!packet->removed);
receiver = routing_[packet->packet.dest_endpoint_id]; receiver = routing_[packet->packet.to.ipaddr()];
packet->removed = true; packet->removed = true;
} }
RTC_CHECK(receiver); RTC_CHECK(receiver);
@ -113,19 +111,18 @@ void EmulatedNetworkNode::Process(Timestamp at_time) {
} }
void EmulatedNetworkNode::SetReceiver( void EmulatedNetworkNode::SetReceiver(
uint64_t dest_endpoint_id, rtc::IPAddress dest_ip,
EmulatedNetworkReceiverInterface* receiver) { EmulatedNetworkReceiverInterface* receiver) {
rtc::CritScope crit(&lock_); rtc::CritScope crit(&lock_);
RTC_CHECK(routing_ EmulatedNetworkReceiverInterface* cur_receiver = routing_[dest_ip];
.insert(std::pair<uint64_t, EmulatedNetworkReceiverInterface*>( RTC_CHECK(cur_receiver == nullptr || cur_receiver == receiver)
dest_endpoint_id, receiver)) << "Routing for dest_ip=" << dest_ip.ToString() << " already exists";
.second) routing_[dest_ip] = receiver;
<< "Routing for endpoint " << dest_endpoint_id << " already exists";
} }
void EmulatedNetworkNode::RemoveReceiver(uint64_t dest_endpoint_id) { void EmulatedNetworkNode::RemoveReceiver(rtc::IPAddress dest_ip) {
rtc::CritScope crit(&lock_); rtc::CritScope crit(&lock_);
routing_.erase(dest_endpoint_id); routing_.erase(dest_ip);
} }
EmulatedEndpoint::EmulatedEndpoint(uint64_t id, EmulatedEndpoint::EmulatedEndpoint(uint64_t id,
@ -137,8 +134,7 @@ EmulatedEndpoint::EmulatedEndpoint(uint64_t id,
is_enabled_(is_enabled), is_enabled_(is_enabled),
send_node_(nullptr), send_node_(nullptr),
clock_(clock), clock_(clock),
next_port_(kFirstEphemeralPort), next_port_(kFirstEphemeralPort) {
connected_endpoint_id_(absl::nullopt) {
constexpr int kIPv4NetworkPrefixLength = 24; constexpr int kIPv4NetworkPrefixLength = 24;
constexpr int kIPv6NetworkPrefixLength = 64; constexpr int kIPv6NetworkPrefixLength = 64;
@ -170,11 +166,10 @@ void EmulatedEndpoint::SendPacket(const rtc::SocketAddress& from,
const rtc::SocketAddress& to, const rtc::SocketAddress& to,
rtc::CopyOnWriteBuffer packet) { rtc::CopyOnWriteBuffer packet) {
RTC_CHECK(from.ipaddr() == peer_local_addr_); RTC_CHECK(from.ipaddr() == peer_local_addr_);
RTC_CHECK(connected_endpoint_id_);
RTC_CHECK(send_node_); RTC_CHECK(send_node_);
send_node_->OnPacketReceived(EmulatedIpPacket( send_node_->OnPacketReceived(
from, to, connected_endpoint_id_.value(), std::move(packet), EmulatedIpPacket(from, to, std::move(packet),
Timestamp::us(clock_->TimeInMicroseconds()))); Timestamp::us(clock_->TimeInMicroseconds())));
} }
absl::optional<uint16_t> EmulatedEndpoint::BindReceiver( absl::optional<uint16_t> EmulatedEndpoint::BindReceiver(
@ -228,9 +223,10 @@ rtc::IPAddress EmulatedEndpoint::GetPeerLocalAddress() const {
} }
void EmulatedEndpoint::OnPacketReceived(EmulatedIpPacket packet) { void EmulatedEndpoint::OnPacketReceived(EmulatedIpPacket packet) {
RTC_CHECK(packet.dest_endpoint_id == id_) RTC_CHECK(packet.to.ipaddr() == peer_local_addr_)
<< "Routing error: wrong destination endpoint. Destination id: " << "Routing error: wrong destination endpoint. Packet.to.ipaddr()=: "
<< packet.dest_endpoint_id << "; Receiver id: " << id_; << packet.to.ipaddr().ToString()
<< "; Receiver peer_local_addr_=" << peer_local_addr_.ToString();
rtc::CritScope crit(&receiver_lock_); rtc::CritScope crit(&receiver_lock_);
auto it = port_to_receiver_.find(packet.to.port()); auto it = port_to_receiver_.find(packet.to.port());
if (it == port_to_receiver_.end()) { if (it == port_to_receiver_.end()) {
@ -268,10 +264,6 @@ EmulatedNetworkNode* EmulatedEndpoint::GetSendNode() const {
return send_node_; return send_node_;
} }
void EmulatedEndpoint::SetConnectedEndpointId(uint64_t endpoint_id) {
connected_endpoint_id_ = endpoint_id;
}
EndpointsContainer::EndpointsContainer( EndpointsContainer::EndpointsContainer(
const std::vector<EmulatedEndpoint*>& endpoints) const std::vector<EmulatedEndpoint*>& endpoints)
: endpoints_(endpoints) {} : endpoints_(endpoints) {}
@ -279,8 +271,8 @@ EndpointsContainer::EndpointsContainer(
EmulatedEndpoint* EndpointsContainer::LookupByLocalAddress( EmulatedEndpoint* EndpointsContainer::LookupByLocalAddress(
const rtc::IPAddress& local_ip) const { const rtc::IPAddress& local_ip) const {
for (auto* endpoint : endpoints_) { for (auto* endpoint : endpoints_) {
rtc::IPAddress peerLocalAddress = endpoint->GetPeerLocalAddress(); rtc::IPAddress peer_local_address = endpoint->GetPeerLocalAddress();
if (peerLocalAddress == local_ip) { if (peer_local_address == local_ip) {
return endpoint; return endpoint;
} }
} }

17
test/scenario/network/network_emulation.h
View File

@ -43,7 +43,6 @@ struct EmulatedIpPacket {
public: public:
EmulatedIpPacket(const rtc::SocketAddress& from, EmulatedIpPacket(const rtc::SocketAddress& from,
const rtc::SocketAddress& to, const rtc::SocketAddress& to,
uint64_t dest_endpoint_id,
rtc::CopyOnWriteBuffer data, rtc::CopyOnWriteBuffer data,
Timestamp arrival_time); Timestamp arrival_time);
~EmulatedIpPacket(); ~EmulatedIpPacket();
@ -59,7 +58,6 @@ struct EmulatedIpPacket {
rtc::SocketAddress from; rtc::SocketAddress from;
rtc::SocketAddress to; rtc::SocketAddress to;
uint64_t dest_endpoint_id;
rtc::CopyOnWriteBuffer data; rtc::CopyOnWriteBuffer data;
Timestamp arrival_time; Timestamp arrival_time;
}; };
@ -87,16 +85,16 @@ class EmulatedNetworkNode : public EmulatedNetworkReceiverInterface {
void OnPacketReceived(EmulatedIpPacket packet) override; void OnPacketReceived(EmulatedIpPacket packet) override;
void Process(Timestamp at_time); void Process(Timestamp at_time);
void SetReceiver(uint64_t dest_endpoint_id, void SetReceiver(rtc::IPAddress dest_ip,
EmulatedNetworkReceiverInterface* receiver); EmulatedNetworkReceiverInterface* receiver);
void RemoveReceiver(uint64_t dest_endpoint_id); void RemoveReceiver(rtc::IPAddress dest_ip);
// Creates a route for the given receiver_id over all the given nodes to the // Creates a route for the given receiver_ip over all the given nodes to the
// given receiver. // given receiver.
static void CreateRoute(uint64_t receiver_id, static void CreateRoute(rtc::IPAddress receiver_ip,
std::vector<EmulatedNetworkNode*> nodes, std::vector<EmulatedNetworkNode*> nodes,
EmulatedNetworkReceiverInterface* receiver); EmulatedNetworkReceiverInterface* receiver);
static void ClearRoute(uint64_t receiver_id, static void ClearRoute(rtc::IPAddress receiver_ip,
std::vector<EmulatedNetworkNode*> nodes); std::vector<EmulatedNetworkNode*> nodes);
private: private:
@ -107,7 +105,7 @@ class EmulatedNetworkNode : public EmulatedNetworkReceiverInterface {
}; };
rtc::CriticalSection lock_; rtc::CriticalSection lock_;
std::map<uint64_t, EmulatedNetworkReceiverInterface*> routing_ std::map<rtc::IPAddress, EmulatedNetworkReceiverInterface*> routing_
RTC_GUARDED_BY(lock_); RTC_GUARDED_BY(lock_);
const std::unique_ptr<NetworkBehaviorInterface> network_behavior_ const std::unique_ptr<NetworkBehaviorInterface> network_behavior_
RTC_GUARDED_BY(lock_); RTC_GUARDED_BY(lock_);
@ -170,7 +168,6 @@ class EmulatedEndpoint : public EmulatedNetworkReceiverInterface {
friend class test::NetworkEmulationManagerImpl; friend class test::NetworkEmulationManagerImpl;
EmulatedNetworkNode* GetSendNode() const; EmulatedNetworkNode* GetSendNode() const;
void SetConnectedEndpointId(uint64_t endpoint_id);
private: private:
static constexpr uint16_t kFirstEphemeralPort = 49152; static constexpr uint16_t kFirstEphemeralPort = 49152;
@ -190,8 +187,6 @@ class EmulatedEndpoint : public EmulatedNetworkReceiverInterface {
uint16_t next_port_ RTC_GUARDED_BY(receiver_lock_); uint16_t next_port_ RTC_GUARDED_BY(receiver_lock_);
std::map<uint16_t, EmulatedNetworkReceiverInterface*> port_to_receiver_ std::map<uint16_t, EmulatedNetworkReceiverInterface*> port_to_receiver_
RTC_GUARDED_BY(receiver_lock_); RTC_GUARDED_BY(receiver_lock_);
absl::optional<uint64_t> connected_endpoint_id_;
}; };
class EmulatedRoute { class EmulatedRoute {

14
test/scenario/network/network_emulation_manager.cc
View File

@ -112,11 +112,10 @@ EmulatedRoute* NetworkEmulationManagerImpl::CreateRoute(
from->SetSendNode(via_nodes[0]); from->SetSendNode(via_nodes[0]);
EmulatedNetworkNode* cur_node = via_nodes[0]; EmulatedNetworkNode* cur_node = via_nodes[0];
for (size_t i = 1; i < via_nodes.size(); ++i) { for (size_t i = 1; i < via_nodes.size(); ++i) {
cur_node->SetReceiver(to->GetId(), via_nodes[i]); cur_node->SetReceiver(to->GetPeerLocalAddress(), via_nodes[i]);
cur_node = via_nodes[i]; cur_node = via_nodes[i];
} }
cur_node->SetReceiver(to->GetId(), to); cur_node->SetReceiver(to->GetPeerLocalAddress(), to);
from->SetConnectedEndpointId(to->GetId());
std::unique_ptr<EmulatedRoute> route = std::unique_ptr<EmulatedRoute> route =
absl::make_unique<EmulatedRoute>(from, std::move(via_nodes), to); absl::make_unique<EmulatedRoute>(from, std::move(via_nodes), to);
@ -130,11 +129,12 @@ void NetworkEmulationManagerImpl::ClearRoute(EmulatedRoute* route) {
// Remove receiver from intermediate nodes. // Remove receiver from intermediate nodes.
for (auto* node : route->via_nodes) { for (auto* node : route->via_nodes) {
node->RemoveReceiver(route->to->GetId()); node->RemoveReceiver(route->to->GetPeerLocalAddress());
} }
// Detach endpoint from current send node. // Detach endpoint from current send node.
if (route->from->GetSendNode()) { if (route->from->GetSendNode()) {
route->from->GetSendNode()->RemoveReceiver(route->to->GetId()); route->from->GetSendNode()->RemoveReceiver(
route->to->GetPeerLocalAddress());
route->from->SetSendNode(nullptr); route->from->SetSendNode(nullptr);
} }
@ -149,10 +149,10 @@ TrafficRoute* NetworkEmulationManagerImpl::CreateTrafficRoute(
// Setup a route via specified nodes. // Setup a route via specified nodes.
EmulatedNetworkNode* cur_node = via_nodes[0]; EmulatedNetworkNode* cur_node = via_nodes[0];
for (size_t i = 1; i < via_nodes.size(); ++i) { for (size_t i = 1; i < via_nodes.size(); ++i) {
cur_node->SetReceiver(endpoint->GetId(), via_nodes[i]); cur_node->SetReceiver(endpoint->GetPeerLocalAddress(), via_nodes[i]);
cur_node = via_nodes[i]; cur_node = via_nodes[i];
} }
cur_node->SetReceiver(endpoint->GetId(), endpoint); cur_node->SetReceiver(endpoint->GetPeerLocalAddress(), endpoint);
std::unique_ptr<TrafficRoute> traffic_route = std::unique_ptr<TrafficRoute> traffic_route =
absl::make_unique<TrafficRoute>(clock_, via_nodes[0], endpoint); absl::make_unique<TrafficRoute>(clock_, via_nodes[0], endpoint);

2
test/scenario/network/traffic_route.cc
View File

@ -89,7 +89,7 @@ void TrafficRoute::SendPacket(size_t packet_size, uint16_t dest_port) {
receiver_->OnPacketReceived(EmulatedIpPacket( receiver_->OnPacketReceived(EmulatedIpPacket(
/*from=*/rtc::SocketAddress(), /*from=*/rtc::SocketAddress(),
rtc::SocketAddress(endpoint_->GetPeerLocalAddress(), dest_port), rtc::SocketAddress(endpoint_->GetPeerLocalAddress(), dest_port),
endpoint_->GetId(), rtc::CopyOnWriteBuffer(packet_size), rtc::CopyOnWriteBuffer(packet_size),
Timestamp::us(clock_->TimeInMicroseconds()))); Timestamp::us(clock_->TimeInMicroseconds())));
} }

34
test/scenario/network_node.cc
View File

@ -106,9 +106,8 @@ bool NetworkNodeTransport::SendRtp(const uint8_t* packet,
rtc::CopyOnWriteBuffer buffer(packet, length, rtc::CopyOnWriteBuffer buffer(packet, length,
length + packet_overhead_.bytes()); length + packet_overhead_.bytes());
buffer.SetSize(length + packet_overhead_.bytes()); buffer.SetSize(length + packet_overhead_.bytes());
send_net_->OnPacketReceived(EmulatedIpPacket( send_net_->OnPacketReceived(
rtc::SocketAddress() /*from*/, rtc::SocketAddress() /*to*/, receiver_id_, EmulatedIpPacket(local_address_, receiver_address_, buffer, send_time));
buffer, send_time));
return true; return true;
} }
@ -119,34 +118,41 @@ bool NetworkNodeTransport::SendRtcp(const uint8_t* packet, size_t length) {
buffer.SetSize(length + packet_overhead_.bytes()); buffer.SetSize(length + packet_overhead_.bytes());
if (!send_net_) if (!send_net_)
return false; return false;
send_net_->OnPacketReceived(EmulatedIpPacket( send_net_->OnPacketReceived(
rtc::SocketAddress() /*from*/, rtc::SocketAddress() /*to*/, receiver_id_, EmulatedIpPacket(local_address_, receiver_address_, buffer, send_time));
buffer, send_time));
return true; return true;
} }
void NetworkNodeTransport::Connect(EmulatedNetworkNode* send_node, void NetworkNodeTransport::Connect(EmulatedNetworkNode* send_node,
uint64_t receiver_id, rtc::IPAddress receiver_ip,
DataSize packet_overhead) { DataSize packet_overhead) {
// Only IPv4 address is supported. We don't use full range of IPs in scenario
// framework and also we need a simple way to convert IP into network_id
// to signal network route.
RTC_CHECK_EQ(receiver_ip.family(), AF_INET);
RTC_CHECK_LE(receiver_ip.v4AddressAsHostOrderInteger(),
std::numeric_limits<uint16_t>::max());
rtc::CritScope crit(&crit_sect_); rtc::CritScope crit(&crit_sect_);
send_net_ = send_node; send_net_ = send_node;
receiver_id_ = receiver_id; receiver_address_ = rtc::SocketAddress(receiver_ip, 0);
packet_overhead_ = packet_overhead; packet_overhead_ = packet_overhead;
rtc::NetworkRoute route; rtc::NetworkRoute route;
route.connected = true; route.connected = true;
route.local_network_id = receiver_id; route.local_network_id =
route.remote_network_id = receiver_id; static_cast<uint16_t>(receiver_ip.v4AddressAsHostOrderInteger());
route.remote_network_id =
static_cast<uint16_t>(receiver_ip.v4AddressAsHostOrderInteger());
std::string transport_name = "dummy"; std::string transport_name = "dummy";
sender_call_->GetTransportControllerSend()->OnNetworkRouteChanged( sender_call_->GetTransportControllerSend()->OnNetworkRouteChanged(
transport_name, route); transport_name, route);
} }
CrossTrafficSource::CrossTrafficSource(EmulatedNetworkReceiverInterface* target, CrossTrafficSource::CrossTrafficSource(EmulatedNetworkReceiverInterface* target,
uint64_t receiver_id, rtc::IPAddress receiver_ip,
CrossTrafficConfig config) CrossTrafficConfig config)
: target_(target), : target_(target),
receiver_id_(receiver_id), receiver_address_(receiver_ip, 0),
config_(config), config_(config),
random_(config.random_seed) {} random_(config.random_seed) {}
@ -179,8 +185,8 @@ void CrossTrafficSource::Process(Timestamp at_time, TimeDelta delta) {
pending_size_ += TrafficRate() * delta; pending_size_ += TrafficRate() * delta;
if (pending_size_ > config_.min_packet_size) { if (pending_size_ > config_.min_packet_size) {
target_->OnPacketReceived(EmulatedIpPacket( target_->OnPacketReceived(EmulatedIpPacket(
rtc::SocketAddress() /*from*/, rtc::SocketAddress() /*to*/, rtc::SocketAddress() /*from*/, receiver_address_,
receiver_id_, rtc::CopyOnWriteBuffer(pending_size_.bytes()), at_time)); rtc::CopyOnWriteBuffer(pending_size_.bytes()), at_time));
pending_size_ = DataSize::Zero(); pending_size_ = DataSize::Zero();
} }
} }

10
test/scenario/network_node.h
View File

@ -75,7 +75,7 @@ class NetworkNodeTransport : public Transport {
bool SendRtcp(const uint8_t* packet, size_t length) override; bool SendRtcp(const uint8_t* packet, size_t length) override;
void Connect(EmulatedNetworkNode* send_node, void Connect(EmulatedNetworkNode* send_node,
uint64_t receiver_id, rtc::IPAddress receiver_ip,
DataSize packet_overhead); DataSize packet_overhead);
DataSize packet_overhead() { DataSize packet_overhead() {
@ -87,8 +87,10 @@ class NetworkNodeTransport : public Transport {
rtc::CriticalSection crit_sect_; rtc::CriticalSection crit_sect_;
Clock* const sender_clock_; Clock* const sender_clock_;
Call* const sender_call_; Call* const sender_call_;
// Store local address here for consistency with receiver address.
const rtc::SocketAddress local_address_;
EmulatedNetworkNode* send_net_ RTC_GUARDED_BY(crit_sect_) = nullptr; EmulatedNetworkNode* send_net_ RTC_GUARDED_BY(crit_sect_) = nullptr;
uint64_t receiver_id_ RTC_GUARDED_BY(crit_sect_) = 0; rtc::SocketAddress receiver_address_ RTC_GUARDED_BY(crit_sect_);
DataSize packet_overhead_ RTC_GUARDED_BY(crit_sect_) = DataSize::Zero(); DataSize packet_overhead_ RTC_GUARDED_BY(crit_sect_) = DataSize::Zero();
}; };
@ -103,12 +105,12 @@ class CrossTrafficSource {
private: private:
friend class Scenario; friend class Scenario;
CrossTrafficSource(EmulatedNetworkReceiverInterface* target, CrossTrafficSource(EmulatedNetworkReceiverInterface* target,
uint64_t receiver_id, rtc::IPAddress receiver_ip,
CrossTrafficConfig config); CrossTrafficConfig config);
void Process(Timestamp at_time, TimeDelta delta); void Process(Timestamp at_time, TimeDelta delta);
EmulatedNetworkReceiverInterface* const target_; EmulatedNetworkReceiverInterface* const target_;
const uint64_t receiver_id_; const rtc::SocketAddress receiver_address_;
CrossTrafficConfig config_; CrossTrafficConfig config_;
webrtc::Random random_; webrtc::Random random_;

34
test/scenario/scenario.cc
View File

@ -155,10 +155,10 @@ void Scenario::ChangeRoute(std::pair<CallClient*, CallClient*> clients,
void Scenario::ChangeRoute(std::pair<CallClient*, CallClient*> clients, void Scenario::ChangeRoute(std::pair<CallClient*, CallClient*> clients,
std::vector<EmulatedNetworkNode*> over_nodes, std::vector<EmulatedNetworkNode*> over_nodes,
DataSize overhead) { DataSize overhead) {
uint64_t route_id = next_route_id_++; rtc::IPAddress route_ip(next_route_id_++);
clients.second->route_overhead_.insert({route_id, overhead}); clients.second->route_overhead_.insert({route_ip, overhead});
EmulatedNetworkNode::CreateRoute(route_id, over_nodes, clients.second); EmulatedNetworkNode::CreateRoute(route_ip, over_nodes, clients.second);
clients.first->transport_->Connect(over_nodes.front(), route_id, overhead); clients.first->transport_->Connect(over_nodes.front(), route_ip, overhead);
} }
SimulatedTimeClient* Scenario::CreateSimulatedTimeClient( SimulatedTimeClient* Scenario::CreateSimulatedTimeClient(
@ -167,11 +167,11 @@ SimulatedTimeClient* Scenario::CreateSimulatedTimeClient(
std::vector<PacketStreamConfig> stream_configs, std::vector<PacketStreamConfig> stream_configs,
std::vector<EmulatedNetworkNode*> send_link, std::vector<EmulatedNetworkNode*> send_link,
std::vector<EmulatedNetworkNode*> return_link) { std::vector<EmulatedNetworkNode*> return_link) {
uint64_t send_id = next_route_id_++; rtc::IPAddress send_ip(next_route_id_++);
uint64_t return_id = next_route_id_++; rtc::IPAddress return_ip(next_route_id_++);
SimulatedTimeClient* client = new SimulatedTimeClient( SimulatedTimeClient* client = new SimulatedTimeClient(
time_controller_.get(), GetLogWriterFactory(name), config, stream_configs, time_controller_.get(), GetLogWriterFactory(name), config, stream_configs,
send_link, return_link, send_id, return_id, Now()); send_link, return_link, send_ip, return_ip, Now());
if (log_writer_factory_ && !name.empty() && if (log_writer_factory_ && !name.empty() &&
config.transport.state_log_interval.IsFinite()) { config.transport.state_log_interval.IsFinite()) {
Every(config.transport.state_log_interval, [this, client]() { Every(config.transport.state_log_interval, [this, client]() {
@ -219,24 +219,24 @@ EmulatedNetworkNode* Scenario::CreateNetworkNode(
void Scenario::TriggerPacketBurst(std::vector<EmulatedNetworkNode*> over_nodes, void Scenario::TriggerPacketBurst(std::vector<EmulatedNetworkNode*> over_nodes,
size_t num_packets, size_t num_packets,
size_t packet_size) { size_t packet_size) {
uint64_t route_id = next_route_id_++; rtc::IPAddress route_ip(next_route_id_++);
EmulatedNetworkNode::CreateRoute(route_id, over_nodes, &null_receiver_); EmulatedNetworkNode::CreateRoute(route_ip, over_nodes, &null_receiver_);
for (size_t i = 0; i < num_packets; ++i) for (size_t i = 0; i < num_packets; ++i)
over_nodes[0]->OnPacketReceived(EmulatedIpPacket( over_nodes[0]->OnPacketReceived(EmulatedIpPacket(
rtc::SocketAddress() /*from*/, rtc::SocketAddress(), /*to*/ rtc::SocketAddress() /*from*/, rtc::SocketAddress(route_ip, 0) /*to*/,
route_id, rtc::CopyOnWriteBuffer(packet_size), Now())); rtc::CopyOnWriteBuffer(packet_size), Now()));
} }
void Scenario::NetworkDelayedAction( void Scenario::NetworkDelayedAction(
std::vector<EmulatedNetworkNode*> over_nodes, std::vector<EmulatedNetworkNode*> over_nodes,
size_t packet_size, size_t packet_size,
std::function<void()> action) { std::function<void()> action) {
uint64_t route_id = next_route_id_++; rtc::IPAddress route_ip(next_route_id_++);
action_receivers_.emplace_back(new ActionReceiver(action)); action_receivers_.emplace_back(new ActionReceiver(action));
EmulatedNetworkNode::CreateRoute(route_id, over_nodes, EmulatedNetworkNode::CreateRoute(route_ip, over_nodes,
action_receivers_.back().get()); action_receivers_.back().get());
over_nodes[0]->OnPacketReceived(EmulatedIpPacket( over_nodes[0]->OnPacketReceived(EmulatedIpPacket(
rtc::SocketAddress() /*from*/, rtc::SocketAddress() /*to*/, route_id, rtc::SocketAddress() /*from*/, rtc::SocketAddress(route_ip, 0) /*to*/,
rtc::CopyOnWriteBuffer(packet_size), Now())); rtc::CopyOnWriteBuffer(packet_size), Now()));
} }
@ -251,11 +251,11 @@ CrossTrafficSource* Scenario::CreateCrossTraffic(
CrossTrafficSource* Scenario::CreateCrossTraffic( CrossTrafficSource* Scenario::CreateCrossTraffic(
std::vector<EmulatedNetworkNode*> over_nodes, std::vector<EmulatedNetworkNode*> over_nodes,
CrossTrafficConfig config) { CrossTrafficConfig config) {
uint64_t route_id = next_route_id_++; rtc::IPAddress route_ip(next_route_id_++);
cross_traffic_sources_.emplace_back( cross_traffic_sources_.emplace_back(
new CrossTrafficSource(over_nodes.front(), route_id, config)); new CrossTrafficSource(over_nodes.front(), route_ip, config));
CrossTrafficSource* node = cross_traffic_sources_.back().get(); CrossTrafficSource* node = cross_traffic_sources_.back().get();
EmulatedNetworkNode::CreateRoute(route_id, over_nodes, &null_receiver_); EmulatedNetworkNode::CreateRoute(route_ip, over_nodes, &null_receiver_);
Every(config.min_packet_interval, Every(config.min_packet_interval,
[this, node](TimeDelta delta) { node->Process(Now(), delta); }); [this, node](TimeDelta delta) { node->Process(Now(), delta); });
return node; return node;

28
test/scenario/simulated_time.cc
View File

@ -112,8 +112,8 @@ rtc::CopyOnWriteBuffer FeedbackToBuffer(
} }
SimulatedSender::SimulatedSender(EmulatedNetworkNode* send_node, SimulatedSender::SimulatedSender(EmulatedNetworkNode* send_node,
uint64_t send_receiver_id) rtc::IPAddress send_receiver_ip)
: send_node_(send_node), send_receiver_id_(send_receiver_id) {} : send_node_(send_node), send_receiver_address_(send_receiver_ip, 0) {}
SimulatedSender::~SimulatedSender() {} SimulatedSender::~SimulatedSender() {}
@ -203,10 +203,10 @@ void SimulatedSender::Update(NetworkControlUpdate update) {
} }
SimulatedFeedback::SimulatedFeedback(SimulatedTimeClientConfig config, SimulatedFeedback::SimulatedFeedback(SimulatedTimeClientConfig config,
uint64_t return_receiver_id, rtc::IPAddress return_receiver_ip,
EmulatedNetworkNode* return_node) EmulatedNetworkNode* return_node)
: config_(config), : config_(config),
return_receiver_id_(return_receiver_id), return_receiver_address_(return_receiver_ip, 0),
return_node_(return_node) {} return_node_(return_node) {}
// Polls receiver side for a feedback report and sends it to the stream sender // Polls receiver side for a feedback report and sends it to the stream sender
@ -231,14 +231,14 @@ void SimulatedFeedback::OnPacketReceived(EmulatedIpPacket packet) {
if (report.receive_times.size() >= if (report.receive_times.size() >=
RawFeedbackReportPacket::MAX_FEEDBACKS) { RawFeedbackReportPacket::MAX_FEEDBACKS) {
return_node_->OnPacketReceived( return_node_->OnPacketReceived(
EmulatedIpPacket(packet.to, packet.from, return_receiver_id_, EmulatedIpPacket(packet.to, return_receiver_address_,
FeedbackToBuffer(report), packet.arrival_time)); FeedbackToBuffer(report), packet.arrival_time));
report = SimpleFeedbackReportPacket(); report = SimpleFeedbackReportPacket();
} }
} }
if (!report.receive_times.empty()) if (!report.receive_times.empty())
return_node_->OnPacketReceived( return_node_->OnPacketReceived(
EmulatedIpPacket(packet.to, packet.from, return_receiver_id_, EmulatedIpPacket(packet.to, return_receiver_address_,
FeedbackToBuffer(report), packet.arrival_time)); FeedbackToBuffer(report), packet.arrival_time));
last_feedback_time_ = packet.arrival_time; last_feedback_time_ = packet.arrival_time;
} }
@ -251,8 +251,8 @@ SimulatedTimeClient::SimulatedTimeClient(
std::vector<PacketStreamConfig> stream_configs, std::vector<PacketStreamConfig> stream_configs,
std::vector<EmulatedNetworkNode*> send_link, std::vector<EmulatedNetworkNode*> send_link,
std::vector<EmulatedNetworkNode*> return_link, std::vector<EmulatedNetworkNode*> return_link,
uint64_t send_receiver_id, rtc::IPAddress send_receiver_ip,
uint64_t return_receiver_id, rtc::IPAddress return_receiver_ip,
Timestamp at_time) Timestamp at_time)
: log_writer_factory_(std::move(log_writer_factory)), : log_writer_factory_(std::move(log_writer_factory)),
network_controller_factory_(time_controller, network_controller_factory_(time_controller,
@ -260,8 +260,8 @@ SimulatedTimeClient::SimulatedTimeClient(
config.transport), config.transport),
send_link_(send_link), send_link_(send_link),
return_link_(return_link), return_link_(return_link),
sender_(send_link.front(), send_receiver_id), sender_(send_link.front(), send_receiver_ip),
feedback_(config, return_receiver_id, return_link.front()) { feedback_(config, return_receiver_ip, return_link.front()) {
current_contraints_.at_time = at_time; current_contraints_.at_time = at_time;
current_contraints_.starting_rate = config.transport.rates.start_rate; current_contraints_.starting_rate = config.transport.rates.start_rate;
current_contraints_.min_data_rate = config.transport.rates.min_rate; current_contraints_.min_data_rate = config.transport.rates.min_rate;
@ -273,8 +273,8 @@ SimulatedTimeClient::SimulatedTimeClient(
congestion_controller_ = network_controller_factory_.Create(initial_config); congestion_controller_ = network_controller_factory_.Create(initial_config);
for (auto& stream_config : stream_configs) for (auto& stream_config : stream_configs)
packet_streams_.emplace_back(new PacketStream(stream_config)); packet_streams_.emplace_back(new PacketStream(stream_config));
EmulatedNetworkNode::CreateRoute(send_receiver_id, send_link, &feedback_); EmulatedNetworkNode::CreateRoute(send_receiver_ip, send_link, &feedback_);
EmulatedNetworkNode::CreateRoute(return_receiver_id, return_link, this); EmulatedNetworkNode::CreateRoute(return_receiver_ip, return_link, this);
CongestionProcess(at_time); CongestionProcess(at_time);
network_controller_factory_.LogCongestionControllerStats(at_time); network_controller_factory_.LogCongestionControllerStats(at_time);
@ -331,8 +331,8 @@ void SimulatedTimeClient::PacerProcess(Timestamp at_time) {
ProcessFrames(at_time); ProcessFrames(at_time);
for (const auto& to_send : sender_.PaceAndPullSendPackets(at_time)) { for (const auto& to_send : sender_.PaceAndPullSendPackets(at_time)) {
sender_.send_node_->OnPacketReceived(EmulatedIpPacket( sender_.send_node_->OnPacketReceived(EmulatedIpPacket(
rtc::SocketAddress() /*from*/, rtc::SocketAddress() /*to*/, rtc::SocketAddress() /*from*/, sender_.send_receiver_address_,
sender_.send_receiver_id_, to_send.data, at_time)); to_send.data, at_time));
Update(congestion_controller_->OnSentPacket(to_send.send_info)); Update(congestion_controller_->OnSentPacket(to_send.send_info));
} }
} }

13
test/scenario/simulated_time.h
View File

@ -50,7 +50,7 @@ class PacketStream {
class SimulatedFeedback : EmulatedNetworkReceiverInterface { class SimulatedFeedback : EmulatedNetworkReceiverInterface {
public: public:
SimulatedFeedback(SimulatedTimeClientConfig config, SimulatedFeedback(SimulatedTimeClientConfig config,
uint64_t return_receiver_id, rtc::IPAddress return_receiver_ip,
EmulatedNetworkNode* return_node); EmulatedNetworkNode* return_node);
void OnPacketReceived(EmulatedIpPacket packet) override; void OnPacketReceived(EmulatedIpPacket packet) override;
@ -58,7 +58,7 @@ class SimulatedFeedback : EmulatedNetworkReceiverInterface {
private: private:
friend class SimulatedTimeClient; friend class SimulatedTimeClient;
const SimulatedTimeClientConfig config_; const SimulatedTimeClientConfig config_;
const uint64_t return_receiver_id_; const rtc::SocketAddress return_receiver_address_;
EmulatedNetworkNode* return_node_; EmulatedNetworkNode* return_node_;
Timestamp last_feedback_time_ = Timestamp::MinusInfinity(); Timestamp last_feedback_time_ = Timestamp::MinusInfinity();
int32_t next_feedback_seq_num_ = 1; int32_t next_feedback_seq_num_ = 1;
@ -88,7 +88,8 @@ class SimulatedSender {
int64_t size; int64_t size;
}; };
SimulatedSender(EmulatedNetworkNode* send_node, uint64_t send_receiver_id); SimulatedSender(EmulatedNetworkNode* send_node,
rtc::IPAddress send_receiver_ip);
SimulatedSender(const SimulatedSender&) = delete; SimulatedSender(const SimulatedSender&) = delete;
~SimulatedSender(); ~SimulatedSender();
TransportPacketsFeedback PullFeedbackReport(SimpleFeedbackReportPacket report, TransportPacketsFeedback PullFeedbackReport(SimpleFeedbackReportPacket report,
@ -99,7 +100,7 @@ class SimulatedSender {
private: private:
friend class SimulatedTimeClient; friend class SimulatedTimeClient;
EmulatedNetworkNode* send_node_; EmulatedNetworkNode* send_node_;
uint64_t send_receiver_id_; const rtc::SocketAddress send_receiver_address_;
PacerConfig pacer_config_; PacerConfig pacer_config_;
DataSize max_in_flight_ = DataSize::Infinity(); DataSize max_in_flight_ = DataSize::Infinity();
@ -127,8 +128,8 @@ class SimulatedTimeClient : EmulatedNetworkReceiverInterface {
std::vector<PacketStreamConfig> stream_configs, std::vector<PacketStreamConfig> stream_configs,
std::vector<EmulatedNetworkNode*> send_link, std::vector<EmulatedNetworkNode*> send_link,
std::vector<EmulatedNetworkNode*> return_link, std::vector<EmulatedNetworkNode*> return_link,
uint64_t send_receiver_id, rtc::IPAddress send_receiver_ip,
uint64_t return_receiver_id, rtc::IPAddress return_receiver_ip,
Timestamp at_time); Timestamp at_time);
SimulatedTimeClient(const SimulatedTimeClient&) = delete; SimulatedTimeClient(const SimulatedTimeClient&) = delete;
~SimulatedTimeClient(); ~SimulatedTimeClient();