mollyim/webrtc
1
0
Fork 0
mirror of https://github.com/mollyim/webrtc.git synced 2025-05-13 05:40:42 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

Remove deprecated API for emulated network stats

Browse source 
Bug: None
Change-Id: Ib70a117d67002d108474214490ed1a8bb61da463
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/283140
Commit-Queue: Artem Titov <titovartem@webrtc.org>
Reviewed-by: Mirko Bonadei <mbonadei@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#38619}
This commit is contained in:
Artem Titov 2022-11-14 10:06:17 +01:00 committed by WebRTC LUCI CQ
parent 31364615d7
commit 5f42cdcb31
8 changed files with 50 additions and 93 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

9
api/test/network_emulation_manager.h
View file

@ -144,10 +144,6 @@ class EmulatedNetworkManagerInterface {
// Passes summarized network stats for endpoints for this manager into
// specified `stats_callback`. Callback will be executed on network emulation
// internal task queue.
// Deprecated.
virtual void GetStats(
std::function<void(std::unique_ptr<EmulatedNetworkStats>)> stats_callback)
const = 0;
virtual void GetStats(
std::function<void(EmulatedNetworkStats)> stats_callback) const = 0;
};
@ -332,11 +328,6 @@ class NetworkEmulationManager {
// Passes combined network stats for all specified `endpoints` into specified
// `stats_callback`. Callback will be executed on network emulation
// internal task queue.
// Deprecated.
virtual void GetStats(
rtc::ArrayView<EmulatedEndpoint* const> endpoints,
std::function<void(std::unique_ptr<EmulatedNetworkStats>)>
stats_callback) = 0;
virtual void GetStats(
rtc::ArrayView<EmulatedEndpoint* const> endpoints,
std::function<void(EmulatedNetworkStats)> stats_callback) = 0;

9
test/network/emulated_network_manager.cc
View file

@ -84,15 +84,6 @@ void EmulatedNetworkManager::StopUpdating() {
}
}
void EmulatedNetworkManager::GetStats(
std::function<void(std::unique_ptr<EmulatedNetworkStats>)> stats_callback)
const {
task_queue_->PostTask([stats_callback, this]() {
stats_callback(std::make_unique<EmulatedNetworkStats>(
endpoints_container_->GetStats()));
});
}
void EmulatedNetworkManager::GetStats(
std::function<void(EmulatedNetworkStats)> stats_callback) const {
task_queue_->PostTask([stats_callback, this]() {

2
test/network/emulated_network_manager.h
View file

@ -58,8 +58,6 @@ class EmulatedNetworkManager : public rtc::NetworkManagerBase,
std::vector<EmulatedEndpoint*> endpoints() const override {
return endpoints_container_->GetEndpoints();
}
void GetStats(std::function<void(std::unique_ptr<EmulatedNetworkStats>)>
stats_callback) const override;
void GetStats(
std::function<void(EmulatedNetworkStats)> stats_callback) const override;

18
test/network/network_emulation_manager.cc
View file

@ -303,24 +303,6 @@ NetworkEmulationManagerImpl::CreateEmulatedNetworkManagerInterface(
return out;
}
void NetworkEmulationManagerImpl::GetStats(
rtc::ArrayView<EmulatedEndpoint* const> endpoints,
std::function<void(std::unique_ptr<EmulatedNetworkStats>)> stats_callback) {
task_queue_.PostTask([endpoints, stats_callback,
stats_gathering_mode = stats_gathering_mode_]() {
EmulatedNetworkStatsBuilder stats_builder(stats_gathering_mode);
for (auto* endpoint : endpoints) {
// It's safe to cast here because EmulatedEndpointImpl can be the only
// implementation of EmulatedEndpoint, because only it has access to
// EmulatedEndpoint constructor.
auto endpoint_impl = static_cast<EmulatedEndpointImpl*>(endpoint);
stats_builder.AddEmulatedNetworkStats(endpoint_impl->stats());
}
stats_callback(
std::make_unique<EmulatedNetworkStats>(stats_builder.Build()));
});
}
void NetworkEmulationManagerImpl::GetStats(
rtc::ArrayView<EmulatedEndpoint* const> endpoints,
std::function<void(EmulatedNetworkStats)> stats_callback) {

3
test/network/network_emulation_manager.h
View file

@ -79,9 +79,6 @@ class NetworkEmulationManagerImpl : public NetworkEmulationManager {
EmulatedNetworkManagerInterface* CreateEmulatedNetworkManagerInterface(
const std::vector<EmulatedEndpoint*>& endpoints) override;
void GetStats(rtc::ArrayView<EmulatedEndpoint* const> endpoints,
std::function<void(std::unique_ptr<EmulatedNetworkStats>)>
stats_callback) override;
void GetStats(
rtc::ArrayView<EmulatedEndpoint* const> endpoints,
std::function<void(EmulatedNetworkStats)> stats_callback) override;

89
test/network/network_emulation_unittest.cc
View file

@ -255,19 +255,19 @@ TEST(NetworkEmulationManagerTest, Run) {
const int64_t single_packet_size = data.size() + kOverheadIpv4Udp;
std::atomic<int> received_stats_count{0};
nt1->GetStats([&](std::unique_ptr<EmulatedNetworkStats> st) {
EXPECT_EQ(st->PacketsSent(), 2000l);
EXPECT_EQ(st->BytesSent().bytes(), single_packet_size * 2000l);
EXPECT_THAT(st->local_addresses,
nt1->GetStats([&](EmulatedNetworkStats st) {
EXPECT_EQ(st.PacketsSent(), 2000l);
EXPECT_EQ(st.BytesSent().bytes(), single_packet_size * 2000l);
EXPECT_THAT(st.local_addresses,
ElementsAreArray({alice_endpoint->GetPeerLocalAddress()}));
EXPECT_EQ(st->PacketsReceived(), 2000l);
EXPECT_EQ(st->BytesReceived().bytes(), single_packet_size * 2000l);
EXPECT_EQ(st->PacketsDiscardedNoReceiver(), 0l);
EXPECT_EQ(st->BytesDiscardedNoReceiver().bytes(), 0l);
EXPECT_EQ(st.PacketsReceived(), 2000l);
EXPECT_EQ(st.BytesReceived().bytes(), single_packet_size * 2000l);
EXPECT_EQ(st.PacketsDiscardedNoReceiver(), 0l);
EXPECT_EQ(st.BytesDiscardedNoReceiver().bytes(), 0l);
rtc::IPAddress bob_ip = bob_endpoint->GetPeerLocalAddress();
std::map<rtc::IPAddress, EmulatedNetworkIncomingStats> source_st =
st->incoming_stats_per_source;
st.incoming_stats_per_source;
ASSERT_EQ(source_st.size(), 1lu);
EXPECT_EQ(source_st.at(bob_ip).packets_received, 2000l);
EXPECT_EQ(source_st.at(bob_ip).bytes_received.bytes(),
@ -276,17 +276,17 @@ TEST(NetworkEmulationManagerTest, Run) {
EXPECT_EQ(source_st.at(bob_ip).bytes_discarded_no_receiver.bytes(), 0l);
std::map<rtc::IPAddress, EmulatedNetworkOutgoingStats> dest_st =
st->outgoing_stats_per_destination;
st.outgoing_stats_per_destination;
ASSERT_EQ(dest_st.size(), 1lu);
EXPECT_EQ(dest_st.at(bob_ip).packets_sent, 2000l);
EXPECT_EQ(dest_st.at(bob_ip).bytes_sent.bytes(),
single_packet_size * 2000l);
// No debug stats are collected by default.
EXPECT_TRUE(st->SentPacketsSizeCounter().IsEmpty());
EXPECT_TRUE(st->sent_packets_queue_wait_time_us.IsEmpty());
EXPECT_TRUE(st->ReceivedPacketsSizeCounter().IsEmpty());
EXPECT_TRUE(st->PacketsDiscardedNoReceiverSizeCounter().IsEmpty());
EXPECT_TRUE(st.SentPacketsSizeCounter().IsEmpty());
EXPECT_TRUE(st.sent_packets_queue_wait_time_us.IsEmpty());
EXPECT_TRUE(st.ReceivedPacketsSizeCounter().IsEmpty());
EXPECT_TRUE(st.PacketsDiscardedNoReceiverSizeCounter().IsEmpty());
EXPECT_TRUE(dest_st.at(bob_ip).sent_packets_size.IsEmpty());
EXPECT_TRUE(source_st.at(bob_ip).received_packets_size.IsEmpty());
EXPECT_TRUE(
@ -294,22 +294,22 @@ TEST(NetworkEmulationManagerTest, Run) {
received_stats_count++;
});
nt2->GetStats([&](std::unique_ptr<EmulatedNetworkStats> st) {
EXPECT_EQ(st->PacketsSent(), 2000l);
EXPECT_EQ(st->BytesSent().bytes(), single_packet_size * 2000l);
EXPECT_THAT(st->local_addresses,
nt2->GetStats([&](EmulatedNetworkStats st) {
EXPECT_EQ(st.PacketsSent(), 2000l);
EXPECT_EQ(st.BytesSent().bytes(), single_packet_size * 2000l);
EXPECT_THAT(st.local_addresses,
ElementsAreArray({bob_endpoint->GetPeerLocalAddress()}));
EXPECT_EQ(st->PacketsReceived(), 2000l);
EXPECT_EQ(st->BytesReceived().bytes(), single_packet_size * 2000l);
EXPECT_EQ(st->PacketsDiscardedNoReceiver(), 0l);
EXPECT_EQ(st->BytesDiscardedNoReceiver().bytes(), 0l);
EXPECT_GT(st->FirstReceivedPacketSize(), DataSize::Zero());
EXPECT_TRUE(st->FirstPacketReceivedTime().IsFinite());
EXPECT_TRUE(st->LastPacketReceivedTime().IsFinite());
EXPECT_EQ(st.PacketsReceived(), 2000l);
EXPECT_EQ(st.BytesReceived().bytes(), single_packet_size * 2000l);
EXPECT_EQ(st.PacketsDiscardedNoReceiver(), 0l);
EXPECT_EQ(st.BytesDiscardedNoReceiver().bytes(), 0l);
EXPECT_GT(st.FirstReceivedPacketSize(), DataSize::Zero());
EXPECT_TRUE(st.FirstPacketReceivedTime().IsFinite());
EXPECT_TRUE(st.LastPacketReceivedTime().IsFinite());
rtc::IPAddress alice_ip = alice_endpoint->GetPeerLocalAddress();
std::map<rtc::IPAddress, EmulatedNetworkIncomingStats> source_st =
st->incoming_stats_per_source;
st.incoming_stats_per_source;
ASSERT_EQ(source_st.size(), 1lu);
EXPECT_EQ(source_st.at(alice_ip).packets_received, 2000l);
EXPECT_EQ(source_st.at(alice_ip).bytes_received.bytes(),
@ -318,17 +318,17 @@ TEST(NetworkEmulationManagerTest, Run) {
EXPECT_EQ(source_st.at(alice_ip).bytes_discarded_no_receiver.bytes(), 0l);
std::map<rtc::IPAddress, EmulatedNetworkOutgoingStats> dest_st =
st->outgoing_stats_per_destination;
st.outgoing_stats_per_destination;
ASSERT_EQ(dest_st.size(), 1lu);
EXPECT_EQ(dest_st.at(alice_ip).packets_sent, 2000l);
EXPECT_EQ(dest_st.at(alice_ip).bytes_sent.bytes(),
single_packet_size * 2000l);
// No debug stats are collected by default.
EXPECT_TRUE(st->SentPacketsSizeCounter().IsEmpty());
EXPECT_TRUE(st->sent_packets_queue_wait_time_us.IsEmpty());
EXPECT_TRUE(st->ReceivedPacketsSizeCounter().IsEmpty());
EXPECT_TRUE(st->PacketsDiscardedNoReceiverSizeCounter().IsEmpty());
EXPECT_TRUE(st.SentPacketsSizeCounter().IsEmpty());
EXPECT_TRUE(st.sent_packets_queue_wait_time_us.IsEmpty());
EXPECT_TRUE(st.ReceivedPacketsSizeCounter().IsEmpty());
EXPECT_TRUE(st.PacketsDiscardedNoReceiverSizeCounter().IsEmpty());
EXPECT_TRUE(dest_st.at(alice_ip).sent_packets_size.IsEmpty());
EXPECT_TRUE(source_st.at(alice_ip).received_packets_size.IsEmpty());
EXPECT_TRUE(
@ -409,23 +409,22 @@ TEST(NetworkEmulationManagerTest, DebugStatsCollectedInDebugMode) {
const int64_t single_packet_size = data.size() + kOverheadIpv4Udp;
std::atomic<int> received_stats_count{0};
nt1->GetStats([&](std::unique_ptr<EmulatedNetworkStats> st) {
nt1->GetStats([&](EmulatedNetworkStats st) {
rtc::IPAddress bob_ip = bob_endpoint->GetPeerLocalAddress();
std::map<rtc::IPAddress, EmulatedNetworkIncomingStats> source_st =
st->incoming_stats_per_source;
st.incoming_stats_per_source;
ASSERT_EQ(source_st.size(), 1lu);
std::map<rtc::IPAddress, EmulatedNetworkOutgoingStats> dest_st =
st->outgoing_stats_per_destination;
st.outgoing_stats_per_destination;
ASSERT_EQ(dest_st.size(), 1lu);
// No debug stats are collected by default.
EXPECT_EQ(st->SentPacketsSizeCounter().NumSamples(), 2000l);
EXPECT_EQ(st->ReceivedPacketsSizeCounter().GetAverage(),
single_packet_size);
EXPECT_EQ(st->sent_packets_queue_wait_time_us.NumSamples(), 2000l);
EXPECT_LT(st->sent_packets_queue_wait_time_us.GetMax(), 1);
EXPECT_TRUE(st->PacketsDiscardedNoReceiverSizeCounter().IsEmpty());
EXPECT_EQ(st.SentPacketsSizeCounter().NumSamples(), 2000l);
EXPECT_EQ(st.ReceivedPacketsSizeCounter().GetAverage(), single_packet_size);
EXPECT_EQ(st.sent_packets_queue_wait_time_us.NumSamples(), 2000l);
EXPECT_LT(st.sent_packets_queue_wait_time_us.GetMax(), 1);
EXPECT_TRUE(st.PacketsDiscardedNoReceiverSizeCounter().IsEmpty());
EXPECT_EQ(dest_st.at(bob_ip).sent_packets_size.NumSamples(), 2000l);
EXPECT_EQ(dest_st.at(bob_ip).sent_packets_size.GetAverage(),
single_packet_size);
@ -504,14 +503,14 @@ TEST(NetworkEmulationManagerTest, ThroughputStats) {
}
std::atomic<int> received_stats_count{0};
nt1->GetStats([&](std::unique_ptr<EmulatedNetworkStats> st) {
EXPECT_EQ(st->PacketsSent(), kNumPacketsSent);
EXPECT_EQ(st->BytesSent().bytes(), kSinglePacketSize * kNumPacketsSent);
nt1->GetStats([&](EmulatedNetworkStats st) {
EXPECT_EQ(st.PacketsSent(), kNumPacketsSent);
EXPECT_EQ(st.BytesSent().bytes(), kSinglePacketSize * kNumPacketsSent);
const double tolerance = 0.95; // Accept 5% tolerance for timing.
EXPECT_GE(st->LastPacketSentTime() - st->FirstPacketSentTime(),
EXPECT_GE(st.LastPacketSentTime() - st.FirstPacketSentTime(),
(kNumPacketsSent - 1) * kDelay * tolerance);
EXPECT_GT(st->AverageSendRate().bps(), 0);
EXPECT_GT(st.AverageSendRate().bps(), 0);
received_stats_count++;
});

4
test/pc/e2e/network_quality_metrics_reporter.cc
View file

@ -110,8 +110,8 @@ EmulatedNetworkStats NetworkQualityMetricsReporter::PopulateStats(
EmulatedNetworkManagerInterface* network) {
rtc::Event wait;
EmulatedNetworkStats stats;
network->GetStats([&](std::unique_ptr<EmulatedNetworkStats> s) {
stats = *s;
network->GetStats([&](EmulatedNetworkStats s) {
stats = std::move(s);
wait.Set();
});
bool stats_received = wait.Wait(kStatsWaitTimeout);

9
test/pc/e2e/stats_based_network_quality_metrics_reporter.cc
View file

@ -55,11 +55,10 @@ EmulatedNetworkStats PopulateStats(std::vector<EmulatedEndpoint*> endpoints,
NetworkEmulationManager* network_emulation) {
rtc::Event stats_loaded;
EmulatedNetworkStats stats;
network_emulation->GetStats(endpoints,
[&](std::unique_ptr<EmulatedNetworkStats> s) {
stats = *s;
stats_loaded.Set();
});
network_emulation->GetStats(endpoints, [&](EmulatedNetworkStats s) {
stats = std::move(s);
stats_loaded.Set();
});
bool stats_received = stats_loaded.Wait(kStatsWaitTimeout);
RTC_CHECK(stats_received);
return stats;