From 37d18485dd4135c4618ee561546b03e722ef6acc Mon Sep 17 00:00:00 2001 From: Artem Titov Date: Tue, 8 Jan 2019 15:41:45 +0100 Subject: [PATCH] Extract NetworkNode abstraction. Extract NetworkNode abstraction and introduce cleaner structure for emulation based on abstract NetworkBehaviorInterface. Bug: webrtc:10138 Change-Id: I89cdae2f3792da34ce169f14592c53515c8ba3ac Reviewed-on: https://webrtc-review.googlesource.com/c/116181 Commit-Queue: Artem Titov Reviewed-by: Sebastian Jansson Cr-Commit-Position: refs/heads/master@{#26159} --- test/scenario/network/BUILD.gn | 2 + test/scenario/network/network_emulation.cc | 98 ++++++++++++++++++++++ test/scenario/network/network_emulation.h | 51 +++++++++++ test/scenario/network_node.cc | 90 +------------------- test/scenario/network_node.h | 53 ++---------- test/scenario/scenario.cc | 59 +++++++------ test/scenario/scenario.h | 31 +++---- test/scenario/simulated_time.cc | 12 +-- test/scenario/simulated_time.h | 16 ++-- 9 files changed, 222 insertions(+), 190 deletions(-) diff --git a/test/scenario/network/BUILD.gn b/test/scenario/network/BUILD.gn index 90a27318c1..7df99ec9cf 100644 --- a/test/scenario/network/BUILD.gn +++ b/test/scenario/network/BUILD.gn @@ -14,8 +14,10 @@ rtc_source_set("emulated_network") { "network_emulation.h", ] deps = [ + "../../../api:simulated_network_api", "../../../api/units:timestamp", "../../../rtc_base:rtc_base", + "//third_party/abseil-cpp/absl/memory:memory", "//third_party/abseil-cpp/absl/types:optional", ] } diff --git a/test/scenario/network/network_emulation.cc b/test/scenario/network/network_emulation.cc index 852c2dd024..ea909e261f 100644 --- a/test/scenario/network/network_emulation.cc +++ b/test/scenario/network/network_emulation.cc @@ -12,7 +12,11 @@ #include +#include "absl/memory/memory.h" +#include "rtc_base/logging.h" + namespace webrtc { +namespace test { EmulatedIpPacket::EmulatedIpPacket(const rtc::SocketAddress& from, const rtc::SocketAddress& to, @@ -29,4 +33,98 @@ EmulatedIpPacket::~EmulatedIpPacket() = default; EmulatedIpPacket::EmulatedIpPacket(EmulatedIpPacket&&) = default; +void EmulatedNetworkNode::CreateRoute( + uint64_t receiver_id, + std::vector nodes, + EmulatedNetworkReceiverInterface* receiver) { + RTC_CHECK(!nodes.empty()); + for (size_t i = 0; i + 1 < nodes.size(); ++i) + nodes[i]->SetReceiver(receiver_id, nodes[i + 1]); + nodes.back()->SetReceiver(receiver_id, receiver); +} + +void EmulatedNetworkNode::ClearRoute(uint64_t receiver_id, + std::vector nodes) { + for (EmulatedNetworkNode* node : nodes) + node->RemoveReceiver(receiver_id); +} + +EmulatedNetworkNode::EmulatedNetworkNode( + std::unique_ptr network_behavior, + size_t packet_overhead) + : network_behavior_(std::move(network_behavior)), + packet_overhead_(packet_overhead) {} + +EmulatedNetworkNode::~EmulatedNetworkNode() = default; + +void EmulatedNetworkNode::OnPacketReceived(EmulatedIpPacket packet) { + rtc::CritScope crit(&lock_); + if (routing_.find(packet.dest_endpoint_id) == routing_.end()) + return; + uint64_t packet_id = next_packet_id_++; + bool sent = network_behavior_->EnqueuePacket(PacketInFlightInfo( + packet.size() + packet_overhead_, packet.arrival_time.us(), packet_id)); + if (sent) { + packets_.emplace_back(StoredPacket{packet_id, std::move(packet), false}); + } +} + +void EmulatedNetworkNode::Process(Timestamp at_time) { + std::vector delivery_infos; + { + rtc::CritScope crit(&lock_); + absl::optional delivery_us = + network_behavior_->NextDeliveryTimeUs(); + if (delivery_us && *delivery_us > at_time.us()) + return; + + delivery_infos = network_behavior_->DequeueDeliverablePackets(at_time.us()); + } + for (PacketDeliveryInfo& delivery_info : delivery_infos) { + StoredPacket* packet = nullptr; + EmulatedNetworkReceiverInterface* receiver = nullptr; + { + rtc::CritScope crit(&lock_); + for (auto& stored_packet : packets_) { + if (stored_packet.id == delivery_info.packet_id) { + packet = &stored_packet; + break; + } + } + RTC_CHECK(packet); + RTC_DCHECK(!packet->removed); + receiver = routing_[packet->packet.dest_endpoint_id]; + packet->removed = true; + } + RTC_CHECK(receiver); + // We don't want to keep the lock here. Otherwise we would get a deadlock if + // the receiver tries to push a new packet. + packet->packet.arrival_time = Timestamp::us(delivery_info.receive_time_us); + receiver->OnPacketReceived(std::move(packet->packet)); + { + rtc::CritScope crit(&lock_); + while (!packets_.empty() && packets_.front().removed) { + packets_.pop_front(); + } + } + } +} + +void EmulatedNetworkNode::SetReceiver( + uint64_t dest_endpoint_id, + EmulatedNetworkReceiverInterface* receiver) { + rtc::CritScope crit(&lock_); + RTC_CHECK(routing_ + .insert(std::pair( + dest_endpoint_id, receiver)) + .second) + << "Such routing already exists"; +} + +void EmulatedNetworkNode::RemoveReceiver(uint64_t dest_endpoint_id) { + rtc::CritScope crit(&lock_); + routing_.erase(dest_endpoint_id); +} + +} // namespace test } // namespace webrtc diff --git a/test/scenario/network/network_emulation.h b/test/scenario/network/network_emulation.h index 82e5f1bf8d..ccb4171f82 100644 --- a/test/scenario/network/network_emulation.h +++ b/test/scenario/network/network_emulation.h @@ -12,12 +12,14 @@ #define TEST_SCENARIO_NETWORK_NETWORK_EMULATION_H_ #include +#include #include #include #include #include #include "absl/types/optional.h" +#include "api/test/simulated_network.h" #include "api/units/timestamp.h" #include "rtc_base/asyncsocket.h" #include "rtc_base/copyonwritebuffer.h" @@ -25,6 +27,7 @@ #include "rtc_base/thread.h" namespace webrtc { +namespace test { struct EmulatedIpPacket { public: @@ -59,6 +62,54 @@ class EmulatedNetworkReceiverInterface { virtual void OnPacketReceived(EmulatedIpPacket packet) = 0; }; +// Represents node in the emulated network. Nodes can be connected with each +// other to form different networks with different behavior. The behavior of +// the node itself is determined by a concrete implementation of +// NetworkBehaviorInterface that is provided on construction. +class EmulatedNetworkNode : public EmulatedNetworkReceiverInterface { + public: + // Creates node based on |network_behavior|. The specified |packet_overhead| + // is added to the size of each packet in the information provided to + // |network_behavior|. + EmulatedNetworkNode( + std::unique_ptr network_behavior, + size_t packet_overhead = 0); + ~EmulatedNetworkNode() override; + RTC_DISALLOW_COPY_AND_ASSIGN(EmulatedNetworkNode); + + void OnPacketReceived(EmulatedIpPacket packet) override; + void Process(Timestamp at_time); + void SetReceiver(uint64_t dest_endpoint_id, + EmulatedNetworkReceiverInterface* receiver); + void RemoveReceiver(uint64_t dest_endpoint_id); + + // Creates a route for the given receiver_id over all the given nodes to the + // given receiver. + static void CreateRoute(uint64_t receiver_id, + std::vector nodes, + EmulatedNetworkReceiverInterface* receiver); + static void ClearRoute(uint64_t receiver_id, + std::vector nodes); + + private: + struct StoredPacket { + uint64_t id; + EmulatedIpPacket packet; + bool removed; + }; + + rtc::CriticalSection lock_; + std::map routing_ + RTC_GUARDED_BY(lock_); + const std::unique_ptr network_behavior_ + RTC_GUARDED_BY(lock_); + const size_t packet_overhead_ RTC_GUARDED_BY(lock_); + std::deque packets_ RTC_GUARDED_BY(lock_); + + uint64_t next_packet_id_ RTC_GUARDED_BY(lock_) = 1; +}; + +} // namespace test } // namespace webrtc #endif // TEST_SCENARIO_NETWORK_NETWORK_EMULATION_H_ diff --git a/test/scenario/network_node.cc b/test/scenario/network_node.cc index 22471757d7..6c08916307 100644 --- a/test/scenario/network_node.cc +++ b/test/scenario/network_node.cc @@ -36,91 +36,6 @@ void ActionReceiver::OnPacketReceived(EmulatedIpPacket packet) { action_(); } -NetworkNode::~NetworkNode() = default; - -NetworkNode::NetworkNode(NetworkNodeConfig config, - std::unique_ptr behavior) - : packet_overhead_(config.packet_overhead.bytes()), - behavior_(std::move(behavior)) {} - -void NetworkNode::SetRoute(uint64_t receiver, - EmulatedNetworkReceiverInterface* node) { - rtc::CritScope crit(&crit_sect_); - routing_[receiver] = node; -} - -void NetworkNode::ClearRoute(uint64_t receiver_id) { - rtc::CritScope crit(&crit_sect_); - auto it = routing_.find(receiver_id); - routing_.erase(it); -} - -void NetworkNode::OnPacketReceived(EmulatedIpPacket packet) { - rtc::CritScope crit(&crit_sect_); - if (routing_.find(packet.dest_endpoint_id) == routing_.end()) - return; - uint64_t packet_id = next_packet_id_++; - if (behavior_->EnqueuePacket( - PacketInFlightInfo(packet.data.size() + packet_overhead_, - packet.arrival_time.us(), packet_id))) { - packets_.emplace_back(StoredPacket{std::move(packet), packet_id, false}); - } -} - -void NetworkNode::Process(Timestamp at_time) { - std::vector delivery_infos; - { - rtc::CritScope crit(&crit_sect_); - absl::optional delivery_us = behavior_->NextDeliveryTimeUs(); - if (delivery_us && *delivery_us > at_time.us()) - return; - - delivery_infos = behavior_->DequeueDeliverablePackets(at_time.us()); - } - for (PacketDeliveryInfo& delivery_info : delivery_infos) { - StoredPacket* packet = nullptr; - EmulatedNetworkReceiverInterface* receiver = nullptr; - { - rtc::CritScope crit(&crit_sect_); - for (StoredPacket& stored_packet : packets_) { - if (stored_packet.id == delivery_info.packet_id) { - packet = &stored_packet; - break; - } - } - RTC_CHECK(packet); - RTC_DCHECK(!packet->removed); - receiver = routing_[packet->packet.dest_endpoint_id]; - packet->removed = true; - } - // We don't want to keep the lock here. Otherwise we would get a deadlock if - // the receiver tries to push a new packet. - packet->packet.arrival_time = Timestamp::us(delivery_info.receive_time_us); - receiver->OnPacketReceived(std::move(packet->packet)); - { - rtc::CritScope crit(&crit_sect_); - while (!packets_.empty() && packets_.front().removed) { - packets_.pop_front(); - } - } - } -} - -void NetworkNode::Route(uint64_t receiver_id, - std::vector nodes, - EmulatedNetworkReceiverInterface* receiver) { - RTC_CHECK(!nodes.empty()); - for (size_t i = 0; i + 1 < nodes.size(); ++i) - nodes[i]->SetRoute(receiver_id, nodes[i + 1]); - nodes.back()->SetRoute(receiver_id, receiver); -} - -void NetworkNode::ClearRoute(uint64_t receiver_id, - std::vector nodes) { - for (NetworkNode* node : nodes) - node->ClearRoute(receiver_id); -} - std::unique_ptr SimulationNode::Create( NetworkNodeConfig config) { RTC_DCHECK(config.mode == NetworkNodeConfig::TrafficMode::kSimulation); @@ -157,7 +72,8 @@ SimulationNode::SimulationNode( NetworkNodeConfig config, std::unique_ptr behavior, SimulatedNetwork* simulation) - : NetworkNode(config, std::move(behavior)), + : EmulatedNetworkNode(std::move(behavior), + config.packet_overhead.bytes_or(0)), simulated_network_(simulation), config_(config) {} @@ -206,7 +122,7 @@ bool NetworkNodeTransport::SendRtcp(const uint8_t* packet, size_t length) { return true; } -void NetworkNodeTransport::Connect(NetworkNode* send_node, +void NetworkNodeTransport::Connect(EmulatedNetworkNode* send_node, uint64_t receiver_id, DataSize packet_overhead) { rtc::CritScope crit(&crit_sect_); diff --git a/test/scenario/network_node.h b/test/scenario/network_node.h index dd28d7fa88..190ecb239e 100644 --- a/test/scenario/network_node.h +++ b/test/scenario/network_node.h @@ -44,51 +44,9 @@ class ActionReceiver : public EmulatedNetworkReceiverInterface { std::function action_; }; -// NetworkNode represents one link in a simulated network. It is created by a -// scenario and can be used when setting up audio and video stream sessions. -class NetworkNode : public EmulatedNetworkReceiverInterface { - public: - ~NetworkNode() override; - RTC_DISALLOW_COPY_AND_ASSIGN(NetworkNode); - - void OnPacketReceived(EmulatedIpPacket packet) override; - // Creates a route for the given receiver_id over all the given nodes to the - // given receiver. - static void Route(uint64_t receiver_id, - std::vector nodes, - EmulatedNetworkReceiverInterface* receiver); - - protected: - friend class Scenario; - friend class AudioStreamPair; - friend class VideoStreamPair; - - NetworkNode(NetworkNodeConfig config, - std::unique_ptr simulation); - static void ClearRoute(uint64_t receiver_id, std::vector nodes); - void Process(Timestamp at_time); - - private: - struct StoredPacket { - EmulatedIpPacket packet; - uint64_t id; - bool removed; - }; - void SetRoute(uint64_t receiver, EmulatedNetworkReceiverInterface* node); - void ClearRoute(uint64_t receiver_id); - rtc::CriticalSection crit_sect_; - size_t packet_overhead_ RTC_GUARDED_BY(crit_sect_); - const std::unique_ptr behavior_ - RTC_GUARDED_BY(crit_sect_); - std::map routing_ - RTC_GUARDED_BY(crit_sect_); - std::deque packets_ RTC_GUARDED_BY(crit_sect_); - - uint64_t next_packet_id_ RTC_GUARDED_BY(crit_sect_) = 1; -}; -// SimulationNode is a NetworkNode that expose an interface for changing run -// time behavior of the underlying simulation. -class SimulationNode : public NetworkNode { +// SimulationNode is a EmulatedNetworkNode that expose an interface for changing +// run time behavior of the underlying simulation. +class SimulationNode : public EmulatedNetworkNode { public: void UpdateConfig(std::function modifier); void PauseTransmissionUntil(Timestamp until); @@ -101,6 +59,7 @@ class SimulationNode : public NetworkNode { std::unique_ptr behavior, SimulatedNetwork* simulation); static std::unique_ptr Create(NetworkNodeConfig config); + SimulatedNetwork* const simulated_network_; NetworkNodeConfig config_; }; @@ -115,7 +74,7 @@ class NetworkNodeTransport : public Transport { const PacketOptions& options) override; bool SendRtcp(const uint8_t* packet, size_t length) override; - void Connect(NetworkNode* send_node, + void Connect(EmulatedNetworkNode* send_node, uint64_t receiver_id, DataSize packet_overhead); @@ -128,7 +87,7 @@ class NetworkNodeTransport : public Transport { rtc::CriticalSection crit_sect_; const Clock* const sender_clock_; Call* const sender_call_; - NetworkNode* 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; DataSize packet_overhead_ RTC_GUARDED_BY(crit_sect_) = DataSize::Zero(); }; diff --git a/test/scenario/scenario.cc b/test/scenario/scenario.cc index 633dfa7001..cadb4b5cf2 100644 --- a/test/scenario/scenario.cc +++ b/test/scenario/scenario.cc @@ -135,21 +135,23 @@ CallClient* Scenario::CreateClient( return CreateClient(name, config); } -CallClientPair* Scenario::CreateRoutes(CallClient* first, - std::vector send_link, - CallClient* second, - std::vector return_link) { +CallClientPair* Scenario::CreateRoutes( + CallClient* first, + std::vector send_link, + CallClient* second, + std::vector return_link) { return CreateRoutes(first, send_link, DataSize::bytes(PacketOverhead::kDefault), second, return_link, DataSize::bytes(PacketOverhead::kDefault)); } -CallClientPair* Scenario::CreateRoutes(CallClient* first, - std::vector send_link, - DataSize first_overhead, - CallClient* second, - std::vector return_link, - DataSize second_overhead) { +CallClientPair* Scenario::CreateRoutes( + CallClient* first, + std::vector send_link, + DataSize first_overhead, + CallClient* second, + std::vector return_link, + DataSize second_overhead) { CallClientPair* client_pair = new CallClientPair(first, second); ChangeRoute(client_pair->forward(), send_link, first_overhead); ChangeRoute(client_pair->reverse(), return_link, second_overhead); @@ -158,16 +160,16 @@ CallClientPair* Scenario::CreateRoutes(CallClient* first, } void Scenario::ChangeRoute(std::pair clients, - std::vector over_nodes) { + std::vector over_nodes) { ChangeRoute(clients, over_nodes, DataSize::bytes(PacketOverhead::kDefault)); } void Scenario::ChangeRoute(std::pair clients, - std::vector over_nodes, + std::vector over_nodes, DataSize overhead) { uint64_t route_id = next_route_id_++; clients.second->route_overhead_.insert({route_id, overhead}); - NetworkNode::Route(route_id, over_nodes, clients.second); + EmulatedNetworkNode::CreateRoute(route_id, over_nodes, clients.second); clients.first->transport_.Connect(over_nodes.front(), route_id, overhead); } @@ -175,8 +177,8 @@ SimulatedTimeClient* Scenario::CreateSimulatedTimeClient( std::string name, SimulatedTimeClientConfig config, std::vector stream_configs, - std::vector send_link, - std::vector return_link) { + std::vector send_link, + std::vector return_link) { uint64_t send_id = next_route_id_++; uint64_t return_id = next_route_id_++; SimulatedTimeClient* client = new SimulatedTimeClient( @@ -213,41 +215,44 @@ SimulationNode* Scenario::CreateSimulationNode(NetworkNodeConfig config) { return sim_node; } -NetworkNode* Scenario::CreateNetworkNode( +EmulatedNetworkNode* Scenario::CreateNetworkNode( NetworkNodeConfig config, std::unique_ptr behavior) { RTC_DCHECK(config.mode == NetworkNodeConfig::TrafficMode::kCustom); - network_nodes_.emplace_back(new NetworkNode(config, std::move(behavior))); - NetworkNode* network_node = network_nodes_.back().get(); + network_nodes_.emplace_back(new EmulatedNetworkNode( + std::move(behavior), config.packet_overhead.bytes_or(0))); + EmulatedNetworkNode* network_node = network_nodes_.back().get(); Every(config.update_frequency, [this, network_node] { network_node->Process(Now()); }); return network_node; } -void Scenario::TriggerPacketBurst(std::vector over_nodes, +void Scenario::TriggerPacketBurst(std::vector over_nodes, size_t num_packets, size_t packet_size) { uint64_t route_id = next_route_id_++; - NetworkNode::Route(route_id, over_nodes, &null_receiver_); + EmulatedNetworkNode::CreateRoute(route_id, over_nodes, &null_receiver_); for (size_t i = 0; i < num_packets; ++i) over_nodes[0]->OnPacketReceived(EmulatedIpPacket( rtc::SocketAddress() /*from*/, rtc::SocketAddress(), /*to*/ route_id, rtc::CopyOnWriteBuffer(packet_size), Now())); } -void Scenario::NetworkDelayedAction(std::vector over_nodes, - size_t packet_size, - std::function action) { +void Scenario::NetworkDelayedAction( + std::vector over_nodes, + size_t packet_size, + std::function action) { uint64_t route_id = next_route_id_++; action_receivers_.emplace_back(new ActionReceiver(action)); - NetworkNode::Route(route_id, over_nodes, action_receivers_.back().get()); + EmulatedNetworkNode::CreateRoute(route_id, over_nodes, + action_receivers_.back().get()); over_nodes[0]->OnPacketReceived(EmulatedIpPacket( rtc::SocketAddress() /*from*/, rtc::SocketAddress() /*to*/, route_id, rtc::CopyOnWriteBuffer(packet_size), Now())); } CrossTrafficSource* Scenario::CreateCrossTraffic( - std::vector over_nodes, + std::vector over_nodes, std::function config_modifier) { CrossTrafficConfig cross_config; config_modifier(&cross_config); @@ -255,13 +260,13 @@ CrossTrafficSource* Scenario::CreateCrossTraffic( } CrossTrafficSource* Scenario::CreateCrossTraffic( - std::vector over_nodes, + std::vector over_nodes, CrossTrafficConfig config) { uint64_t route_id = next_route_id_++; cross_traffic_sources_.emplace_back( new CrossTrafficSource(over_nodes.front(), route_id, config)); CrossTrafficSource* node = cross_traffic_sources_.back().get(); - NetworkNode::Route(route_id, over_nodes, &null_receiver_); + EmulatedNetworkNode::CreateRoute(route_id, over_nodes, &null_receiver_); Every(config.min_packet_interval, [this, node](TimeDelta delta) { node->Process(Now(), delta); }); return node; diff --git a/test/scenario/scenario.h b/test/scenario/scenario.h index 38bef442ec..b5b29d7fed 100644 --- a/test/scenario/scenario.h +++ b/test/scenario/scenario.h @@ -69,7 +69,7 @@ class Scenario { SimulationNode* CreateSimulationNode(NetworkNodeConfig config); SimulationNode* CreateSimulationNode( std::function config_modifier); - NetworkNode* CreateNetworkNode( + EmulatedNetworkNode* CreateNetworkNode( NetworkNodeConfig config, std::unique_ptr behavior); @@ -79,30 +79,30 @@ class Scenario { std::function config_modifier); CallClientPair* CreateRoutes(CallClient* first, - std::vector send_link, + std::vector send_link, CallClient* second, - std::vector return_link); + std::vector return_link); CallClientPair* CreateRoutes(CallClient* first, - std::vector send_link, + std::vector send_link, DataSize first_overhead, CallClient* second, - std::vector return_link, + std::vector return_link, DataSize second_overhead); void ChangeRoute(std::pair clients, - std::vector over_nodes); + std::vector over_nodes); void ChangeRoute(std::pair clients, - std::vector over_nodes, + std::vector over_nodes, DataSize overhead); SimulatedTimeClient* CreateSimulatedTimeClient( std::string name, SimulatedTimeClientConfig config, std::vector stream_configs, - std::vector send_link, - std::vector return_link); + std::vector send_link, + std::vector return_link); VideoStreamPair* CreateVideoStream( std::pair clients, @@ -119,10 +119,11 @@ class Scenario { AudioStreamConfig config); CrossTrafficSource* CreateCrossTraffic( - std::vector over_nodes, + std::vector over_nodes, std::function config_modifier); - CrossTrafficSource* CreateCrossTraffic(std::vector over_nodes, - CrossTrafficConfig config); + CrossTrafficSource* CreateCrossTraffic( + std::vector over_nodes, + CrossTrafficConfig config); // Runs the provided function with a fixed interval. RepeatedActivity* Every(TimeDelta interval, @@ -133,7 +134,7 @@ class Scenario { void At(TimeDelta offset, std::function function); // Sends a packet over the nodes and runs |action| when it has been delivered. - void NetworkDelayedAction(std::vector over_nodes, + void NetworkDelayedAction(std::vector over_nodes, size_t packet_size, std::function action); @@ -148,7 +149,7 @@ class Scenario { void Stop(); // Triggers sending of dummy packets over the given nodes. - void TriggerPacketBurst(std::vector over_nodes, + void TriggerPacketBurst(std::vector over_nodes, size_t num_packets, size_t packet_size); @@ -180,7 +181,7 @@ class Scenario { std::vector> clients_; std::vector> client_pairs_; - std::vector> network_nodes_; + std::vector> network_nodes_; std::vector> cross_traffic_sources_; std::vector> video_streams_; std::vector> audio_streams_; diff --git a/test/scenario/simulated_time.cc b/test/scenario/simulated_time.cc index 4d7465ff1c..7be17559c7 100644 --- a/test/scenario/simulated_time.cc +++ b/test/scenario/simulated_time.cc @@ -111,7 +111,7 @@ rtc::CopyOnWriteBuffer FeedbackToBuffer( sizeof(RawFeedbackReportPacket)); } -SimulatedSender::SimulatedSender(NetworkNode* send_node, +SimulatedSender::SimulatedSender(EmulatedNetworkNode* send_node, uint64_t send_receiver_id) : send_node_(send_node), send_receiver_id_(send_receiver_id) {} @@ -204,7 +204,7 @@ void SimulatedSender::Update(NetworkControlUpdate update) { SimulatedFeedback::SimulatedFeedback(SimulatedTimeClientConfig config, uint64_t return_receiver_id, - NetworkNode* return_node) + EmulatedNetworkNode* return_node) : config_(config), return_receiver_id_(return_receiver_id), return_node_(return_node) {} @@ -248,8 +248,8 @@ SimulatedTimeClient::SimulatedTimeClient( std::string log_filename, SimulatedTimeClientConfig config, std::vector stream_configs, - std::vector send_link, - std::vector return_link, + std::vector send_link, + std::vector return_link, uint64_t send_receiver_id, uint64_t return_receiver_id, Timestamp at_time) @@ -269,8 +269,8 @@ SimulatedTimeClient::SimulatedTimeClient( congestion_controller_ = network_controller_factory_.Create(initial_config); for (auto& stream_config : stream_configs) packet_streams_.emplace_back(new PacketStream(stream_config)); - NetworkNode::Route(send_receiver_id, send_link, &feedback_); - NetworkNode::Route(return_receiver_id, return_link, this); + EmulatedNetworkNode::CreateRoute(send_receiver_id, send_link, &feedback_); + EmulatedNetworkNode::CreateRoute(return_receiver_id, return_link, this); CongestionProcess(at_time); network_controller_factory_.LogCongestionControllerStats(at_time); diff --git a/test/scenario/simulated_time.h b/test/scenario/simulated_time.h index 9cd685c12b..be9331ca77 100644 --- a/test/scenario/simulated_time.h +++ b/test/scenario/simulated_time.h @@ -51,7 +51,7 @@ class SimulatedFeedback : EmulatedNetworkReceiverInterface { public: SimulatedFeedback(SimulatedTimeClientConfig config, uint64_t return_receiver_id, - NetworkNode* return_node); + EmulatedNetworkNode* return_node); void OnPacketReceived(EmulatedIpPacket packet) override; @@ -59,7 +59,7 @@ class SimulatedFeedback : EmulatedNetworkReceiverInterface { friend class SimulatedTimeClient; const SimulatedTimeClientConfig config_; const uint64_t return_receiver_id_; - NetworkNode* return_node_; + EmulatedNetworkNode* return_node_; Timestamp last_feedback_time_ = Timestamp::MinusInfinity(); int32_t next_feedback_seq_num_ = 1; std::map receive_times_; @@ -88,7 +88,7 @@ class SimulatedSender { int64_t size; }; - SimulatedSender(NetworkNode* send_node, uint64_t send_receiver_id); + SimulatedSender(EmulatedNetworkNode* send_node, uint64_t send_receiver_id); SimulatedSender(const SimulatedSender&) = delete; ~SimulatedSender(); TransportPacketsFeedback PullFeedbackReport(SimpleFeedbackReportPacket report, @@ -98,7 +98,7 @@ class SimulatedSender { private: friend class SimulatedTimeClient; - NetworkNode* send_node_; + EmulatedNetworkNode* send_node_; uint64_t send_receiver_id_; PacerConfig pacer_config_; DataSize max_in_flight_ = DataSize::Infinity(); @@ -123,8 +123,8 @@ class SimulatedTimeClient : EmulatedNetworkReceiverInterface { SimulatedTimeClient(std::string log_filename, SimulatedTimeClientConfig config, std::vector stream_configs, - std::vector send_link, - std::vector return_link, + std::vector send_link, + std::vector return_link, uint64_t send_receiver_id, uint64_t return_receiver_id, Timestamp at_time); @@ -146,8 +146,8 @@ class SimulatedTimeClient : EmulatedNetworkReceiverInterface { friend class Scenario; LoggingNetworkControllerFactory network_controller_factory_; std::unique_ptr congestion_controller_; - std::vector send_link_; - std::vector return_link_; + std::vector send_link_; + std::vector return_link_; SimulatedSender sender_; SimulatedFeedback feedback_; TargetRateConstraints current_contraints_;