From 01d70a3978d5a404aa8b490d1b84ff529123ad4b Mon Sep 17 00:00:00 2001 From: asapersson Date: Fri, 20 May 2016 06:29:46 -0700 Subject: [PATCH] Add a default implementation in metrics_default.cc of histograms methods in system_wrappers/interface/metrics.h. Updated tests to use the default implementation and removed the test implementation (webrtc/test/histograms.h). BUG= Review-Url: https://codereview.webrtc.org/1915523002 Cr-Commit-Position: refs/heads/master@{#12829} --- webrtc/call/call_perf_tests.cc | 6 +- .../codecs/vp8/screenshare_layers_unittest.cc | 62 ++-- .../video_coding/jitter_buffer_unittest.cc | 26 +- webrtc/system_wrappers/BUILD.gn | 1 + .../system_wrappers/include/metrics_default.h | 57 ++++ .../system_wrappers/source/metrics_default.cc | 277 +++++++++++++++++- .../source/metrics_default_unittest.cc | 154 ++++++++++ .../source/metrics_unittest.cc | 141 ++++----- webrtc/system_wrappers/system_wrappers.gyp | 1 + .../system_wrappers/system_wrappers_tests.gyp | 3 +- webrtc/test/BUILD.gn | 17 +- webrtc/test/histogram.cc | 97 ------ webrtc/test/histogram.h | 33 --- webrtc/test/test.gyp | 16 +- webrtc/test/test_main.cc | 2 + webrtc/test/test_suite.cc | 2 + webrtc/video/call_stats_unittest.cc | 9 +- webrtc/video/end_to_end_tests.cc | 196 ++++++------- webrtc/video/send_delay_stats_unittest.cc | 9 +- .../video/send_statistics_proxy_unittest.cc | 235 +++++++-------- 20 files changed, 827 insertions(+), 517 deletions(-) create mode 100644 webrtc/system_wrappers/include/metrics_default.h create mode 100644 webrtc/system_wrappers/source/metrics_default_unittest.cc delete mode 100644 webrtc/test/histogram.cc delete mode 100644 webrtc/test/histogram.h diff --git a/webrtc/call/call_perf_tests.cc b/webrtc/call/call_perf_tests.cc index 329c1f25b6..11861ac683 100644 --- a/webrtc/call/call_perf_tests.cc +++ b/webrtc/call/call_perf_tests.cc @@ -26,6 +26,7 @@ #include "webrtc/modules/rtp_rtcp/include/rtp_header_parser.h" #include "webrtc/modules/rtp_rtcp/source/rtcp_utility.h" #include "webrtc/system_wrappers/include/critical_section_wrapper.h" +#include "webrtc/system_wrappers/include/metrics_default.h" #include "webrtc/system_wrappers/include/rtp_to_ntp.h" #include "webrtc/test/call_test.h" #include "webrtc/test/direct_transport.h" @@ -36,7 +37,6 @@ #include "webrtc/test/fake_encoder.h" #include "webrtc/test/frame_generator.h" #include "webrtc/test/frame_generator_capturer.h" -#include "webrtc/test/histogram.h" #include "webrtc/test/rtp_rtcp_observer.h" #include "webrtc/test/testsupport/fileutils.h" #include "webrtc/test/testsupport/perf_test.h" @@ -150,7 +150,7 @@ void CallPerfTest::TestAudioVideoSync(FecMode fec, const uint32_t kAudioSendSsrc = 1234; const uint32_t kAudioRecvSsrc = 5678; - test::ClearHistograms(); + metrics::Reset(); VoiceEngine* voice_engine = VoiceEngine::Create(); VoEBase* voe_base = VoEBase::GetInterface(voice_engine); VoECodec* voe_codec = VoECodec::GetInterface(voice_engine); @@ -300,7 +300,7 @@ void CallPerfTest::TestAudioVideoSync(FecMode fec, VoiceEngine::Delete(voice_engine); - EXPECT_EQ(1, test::NumHistogramSamples("WebRTC.Video.AVSyncOffsetInMs")); + EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.AVSyncOffsetInMs")); } TEST_F(CallPerfTest, PlaysOutAudioAndVideoInSyncWithVideoNtpDrift) { diff --git a/webrtc/modules/video_coding/codecs/vp8/screenshare_layers_unittest.cc b/webrtc/modules/video_coding/codecs/vp8/screenshare_layers_unittest.cc index 667f6b0922..2711de0adc 100644 --- a/webrtc/modules/video_coding/codecs/vp8/screenshare_layers_unittest.cc +++ b/webrtc/modules/video_coding/codecs/vp8/screenshare_layers_unittest.cc @@ -19,7 +19,7 @@ #include "webrtc/modules/video_coding/utility/mock/mock_frame_dropper.h" #include "webrtc/system_wrappers/include/clock.h" #include "webrtc/system_wrappers/include/metrics.h" -#include "webrtc/test/histogram.h" +#include "webrtc/system_wrappers/include/metrics_default.h" using ::testing::_; using ::testing::NiceMock; @@ -474,6 +474,7 @@ TEST_F(ScreenshareLayerTest, RespectsMaxIntervalBetweenFrames) { } TEST_F(ScreenshareLayerTest, UpdatesHistograms) { + metrics::Reset(); ConfigureBitrates(); vpx_codec_enc_cfg_t cfg = GetConfig(); bool trigger_drop = false; @@ -519,42 +520,35 @@ TEST_F(ScreenshareLayerTest, UpdatesHistograms) { layers_.reset(); // Histograms are reported on destruction. - EXPECT_EQ(1, test::NumHistogramSamples( - "WebRTC.Video.Screenshare.Layer0.FrameRate")); - EXPECT_EQ(1, test::NumHistogramSamples( - "WebRTC.Video.Screenshare.Layer1.FrameRate")); + EXPECT_EQ(1, + metrics::NumSamples("WebRTC.Video.Screenshare.Layer0.FrameRate")); + EXPECT_EQ(1, + metrics::NumSamples("WebRTC.Video.Screenshare.Layer1.FrameRate")); + EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.Screenshare.FramesPerDrop")); + EXPECT_EQ(1, + metrics::NumSamples("WebRTC.Video.Screenshare.FramesPerOvershoot")); + EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.Screenshare.Layer0.Qp")); + EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.Screenshare.Layer1.Qp")); EXPECT_EQ( - 1, test::NumHistogramSamples("WebRTC.Video.Screenshare.FramesPerDrop")); - EXPECT_EQ(1, test::NumHistogramSamples( - "WebRTC.Video.Screenshare.FramesPerOvershoot")); - EXPECT_EQ(1, test::NumHistogramSamples("WebRTC.Video.Screenshare.Layer0.Qp")); - EXPECT_EQ(1, test::NumHistogramSamples("WebRTC.Video.Screenshare.Layer1.Qp")); - EXPECT_EQ(1, test::NumHistogramSamples( - "WebRTC.Video.Screenshare.Layer0.TargetBitrate")); - EXPECT_EQ(1, test::NumHistogramSamples( - "WebRTC.Video.Screenshare.Layer1.TargetBitrate")); + 1, metrics::NumSamples("WebRTC.Video.Screenshare.Layer0.TargetBitrate")); + EXPECT_EQ( + 1, metrics::NumSamples("WebRTC.Video.Screenshare.Layer1.TargetBitrate")); - EXPECT_GT( - test::LastHistogramSample("WebRTC.Video.Screenshare.Layer0.FrameRate"), - 1); - EXPECT_GT( - test::LastHistogramSample("WebRTC.Video.Screenshare.Layer1.FrameRate"), - 1); - EXPECT_GT(test::LastHistogramSample("WebRTC.Video.Screenshare.FramesPerDrop"), + EXPECT_GT(metrics::MinSample("WebRTC.Video.Screenshare.Layer0.FrameRate"), 1); + EXPECT_GT(metrics::MinSample("WebRTC.Video.Screenshare.Layer1.FrameRate"), 1); + EXPECT_GT(metrics::MinSample("WebRTC.Video.Screenshare.FramesPerDrop"), 1); + EXPECT_GT(metrics::MinSample("WebRTC.Video.Screenshare.FramesPerOvershoot"), 1); - EXPECT_GT( - test::LastHistogramSample("WebRTC.Video.Screenshare.FramesPerOvershoot"), - 1); - EXPECT_EQ(kTl0Qp, - test::LastHistogramSample("WebRTC.Video.Screenshare.Layer0.Qp")); - EXPECT_EQ(kTl1Qp, - test::LastHistogramSample("WebRTC.Video.Screenshare.Layer1.Qp")); - EXPECT_EQ(kDefaultTl0BitrateKbps, - test::LastHistogramSample( - "WebRTC.Video.Screenshare.Layer0.TargetBitrate")); - EXPECT_EQ(kDefaultTl1BitrateKbps, - test::LastHistogramSample( - "WebRTC.Video.Screenshare.Layer1.TargetBitrate")); + EXPECT_EQ(1, + metrics::NumEvents("WebRTC.Video.Screenshare.Layer0.Qp", kTl0Qp)); + EXPECT_EQ(1, + metrics::NumEvents("WebRTC.Video.Screenshare.Layer1.Qp", kTl1Qp)); + EXPECT_EQ(1, + metrics::NumEvents("WebRTC.Video.Screenshare.Layer0.TargetBitrate", + kDefaultTl0BitrateKbps)); + EXPECT_EQ(1, + metrics::NumEvents("WebRTC.Video.Screenshare.Layer1.TargetBitrate", + kDefaultTl1BitrateKbps)); } } // namespace webrtc diff --git a/webrtc/modules/video_coding/jitter_buffer_unittest.cc b/webrtc/modules/video_coding/jitter_buffer_unittest.cc index af9c20aaef..9bdce7a0ac 100644 --- a/webrtc/modules/video_coding/jitter_buffer_unittest.cc +++ b/webrtc/modules/video_coding/jitter_buffer_unittest.cc @@ -24,8 +24,8 @@ #include "webrtc/system_wrappers/include/clock.h" #include "webrtc/system_wrappers/include/field_trial.h" #include "webrtc/system_wrappers/include/metrics.h" +#include "webrtc/system_wrappers/include/metrics_default.h" #include "webrtc/test/field_trial.h" -#include "webrtc/test/histogram.h" namespace webrtc { @@ -498,7 +498,7 @@ TEST_P(TestBasicJitterBuffer, SinglePacketFrame) { } TEST_P(TestBasicJitterBuffer, VerifyHistogramStats) { - test::ClearHistograms(); + metrics::Reset(); // Always start with a complete key frame when not allowing errors. jitter_buffer_->SetDecodeErrorMode(kNoErrors); packet_->frameType = kVideoFrameKey; @@ -518,25 +518,21 @@ TEST_P(TestBasicJitterBuffer, VerifyHistogramStats) { // Verify that histograms are updated when the jitter buffer is stopped. clock_->AdvanceTimeMilliseconds(metrics::kMinRunTimeInSeconds * 1000); jitter_buffer_->Stop(); + EXPECT_EQ(1, metrics::NumEvents("WebRTC.Video.DiscardedPacketsInPercent", 0)); + EXPECT_EQ(1, + metrics::NumEvents("WebRTC.Video.DuplicatedPacketsInPercent", 0)); EXPECT_EQ( - 0, test::LastHistogramSample("WebRTC.Video.DiscardedPacketsInPercent")); + 1, metrics::NumSamples("WebRTC.Video.CompleteFramesReceivedPerSecond")); EXPECT_EQ( - 0, test::LastHistogramSample("WebRTC.Video.DuplicatedPacketsInPercent")); - EXPECT_NE(-1, test::LastHistogramSample( - "WebRTC.Video.CompleteFramesReceivedPerSecond")); - EXPECT_EQ(1000, test::LastHistogramSample( - "WebRTC.Video.KeyFramesReceivedInPermille")); + 1, metrics::NumEvents("WebRTC.Video.KeyFramesReceivedInPermille", 1000)); // Verify that histograms are not updated if stop is called again. jitter_buffer_->Stop(); + EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.DiscardedPacketsInPercent")); + EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.DuplicatedPacketsInPercent")); EXPECT_EQ( - 1, test::NumHistogramSamples("WebRTC.Video.DiscardedPacketsInPercent")); - EXPECT_EQ( - 1, test::NumHistogramSamples("WebRTC.Video.DuplicatedPacketsInPercent")); - EXPECT_EQ(1, test::NumHistogramSamples( - "WebRTC.Video.CompleteFramesReceivedPerSecond")); - EXPECT_EQ( - 1, test::NumHistogramSamples("WebRTC.Video.KeyFramesReceivedInPermille")); + 1, metrics::NumSamples("WebRTC.Video.CompleteFramesReceivedPerSecond")); + EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.KeyFramesReceivedInPermille")); } TEST_P(TestBasicJitterBuffer, DualPacketFrame) { diff --git a/webrtc/system_wrappers/BUILD.gn b/webrtc/system_wrappers/BUILD.gn index 66e6df5cc1..da785e2fca 100644 --- a/webrtc/system_wrappers/BUILD.gn +++ b/webrtc/system_wrappers/BUILD.gn @@ -148,6 +148,7 @@ source_set("field_trial_default") { source_set("metrics_default") { sources = [ + "include/metrics_default.h", "source/metrics_default.cc", ] diff --git a/webrtc/system_wrappers/include/metrics_default.h b/webrtc/system_wrappers/include/metrics_default.h new file mode 100644 index 0000000000..e4b790bc16 --- /dev/null +++ b/webrtc/system_wrappers/include/metrics_default.h @@ -0,0 +1,57 @@ +/* + * Copyright (c) 2016 The WebRTC project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +#ifndef WEBRTC_SYSTEM_WRAPPERS_INCLUDE_METRICS_DEFAULT_H_ +#define WEBRTC_SYSTEM_WRAPPERS_INCLUDE_METRICS_DEFAULT_H_ + +#include +#include +#include + +namespace webrtc { +namespace metrics { + +struct SampleInfo { + SampleInfo(const std::string& name, int min, int max, size_t bucket_count); + ~SampleInfo(); + + const std::string name; + const int min; + const int max; + const size_t bucket_count; + std::map samples; // +}; + +// Enables collection of samples. +// This method should be called before any other call into webrtc. +void Enable(); + +// Gets histograms and clears all samples. +void GetAndReset( + std::map>* histograms); + +// Functions below are mainly for testing. + +// Clears all samples. +void Reset(); + +// Returns the number of times the |sample| has been added to the histogram. +int NumEvents(const std::string& name, int sample); + +// Returns the total number of added samples to the histogram. +int NumSamples(const std::string& name); + +// Returns the minimum sample value (or -1 if the histogram has no samples). +int MinSample(const std::string& name); + +} // namespace metrics +} // namespace webrtc + +#endif // WEBRTC_SYSTEM_WRAPPERS_INCLUDE_METRICS_DEFAULT_H_ diff --git a/webrtc/system_wrappers/source/metrics_default.cc b/webrtc/system_wrappers/source/metrics_default.cc index 48c9111e1b..34d33a2179 100644 --- a/webrtc/system_wrappers/source/metrics_default.cc +++ b/webrtc/system_wrappers/source/metrics_default.cc @@ -7,6 +7,10 @@ // be found in the AUTHORS file in the root of the source tree. // +#include "webrtc/system_wrappers/include/metrics_default.h" + +#include "webrtc/base/criticalsection.h" +#include "webrtc/base/thread_annotations.h" #include "webrtc/system_wrappers/include/metrics.h" // Default implementation of histogram methods for WebRTC clients that do not @@ -14,16 +18,277 @@ namespace webrtc { namespace metrics { +class Histogram; -Histogram* HistogramFactoryGetCounts(const std::string& name, int min, int max, - int bucket_count) { return NULL; } +namespace { +// Limit for the maximum number of sample values that can be stored. +// TODO(asapersson): Consider using bucket count (and set up +// linearly/exponentially spaced buckets) if samples are logged more frequently. +const int kMaxSampleMapSize = 2000; +class RtcHistogram { + public: + RtcHistogram(const std::string& name, int min, int max, int bucket_count) + : min_(min), max_(max), info_(name, min, max, bucket_count) { + RTC_DCHECK_GT(bucket_count, 0); + } + + void Add(int sample) { + if (sample < min_) + sample = min_ - 1; // Underflow bucket. + if (sample > max_) + sample = max_; + + rtc::CritScope cs(&crit_); + if (info_.samples.size() == kMaxSampleMapSize && + info_.samples.find(sample) == info_.samples.end()) { + return; + } + ++info_.samples[sample]; + } + + // Returns a copy (or nullptr if there are no samples) and clears samples. + std::unique_ptr GetAndReset() { + rtc::CritScope cs(&crit_); + if (info_.samples.empty()) + return nullptr; + + SampleInfo* copy = + new SampleInfo(info_.name, info_.min, info_.max, info_.bucket_count); + copy->samples = info_.samples; + info_.samples.clear(); + return std::unique_ptr(copy); + } + + const std::string& name() const { return info_.name; } + + // Functions only for testing. + void Reset() { + rtc::CritScope cs(&crit_); + info_.samples.clear(); + } + + int NumEvents(int sample) const { + rtc::CritScope cs(&crit_); + const auto it = info_.samples.find(sample); + return (it == info_.samples.end()) ? 0 : it->second; + } + + int NumSamples() const { + int num_samples = 0; + rtc::CritScope cs(&crit_); + for (const auto& sample : info_.samples) { + num_samples += sample.second; + } + return num_samples; + } + + int MinSample() const { + rtc::CritScope cs(&crit_); + return (info_.samples.empty()) ? -1 : info_.samples.begin()->first; + } + + private: + rtc::CriticalSection crit_; + const int min_; + const int max_; + SampleInfo info_ GUARDED_BY(crit_); + + RTC_DISALLOW_COPY_AND_ASSIGN(RtcHistogram); +}; + +class RtcHistogramMap { + public: + RtcHistogramMap() {} + ~RtcHistogramMap() {} + + Histogram* GetCountsHistogram(const std::string& name, + int min, + int max, + int bucket_count) { + rtc::CritScope cs(&crit_); + const auto& it = map_.find(name); + if (it != map_.end()) + return reinterpret_cast(it->second.get()); + + RtcHistogram* hist = new RtcHistogram(name, min, max, bucket_count); + map_[name].reset(hist); + return reinterpret_cast(hist); + } + + Histogram* GetEnumerationHistogram(const std::string& name, int boundary) { + rtc::CritScope cs(&crit_); + const auto& it = map_.find(name); + if (it != map_.end()) + return reinterpret_cast(it->second.get()); + + RtcHistogram* hist = new RtcHistogram(name, 1, boundary, boundary + 1); + map_[name].reset(hist); + return reinterpret_cast(hist); + } + + void GetAndReset( + std::map>* histograms) { + rtc::CritScope cs(&crit_); + for (const auto& kv : map_) { + std::unique_ptr info = kv.second->GetAndReset(); + if (info) + histograms->insert(std::make_pair(kv.first, std::move(info))); + } + } + + // Functions only for testing. + void Reset() { + rtc::CritScope cs(&crit_); + for (const auto& kv : map_) + kv.second->Reset(); + } + + int NumEvents(const std::string& name, int sample) const { + rtc::CritScope cs(&crit_); + const auto& it = map_.find(name); + return (it == map_.end()) ? 0 : it->second->NumEvents(sample); + } + + int NumSamples(const std::string& name) const { + rtc::CritScope cs(&crit_); + const auto& it = map_.find(name); + return (it == map_.end()) ? 0 : it->second->NumSamples(); + } + + int MinSample(const std::string& name) const { + rtc::CritScope cs(&crit_); + const auto& it = map_.find(name); + return (it == map_.end()) ? -1 : it->second->MinSample(); + } + + private: + rtc::CriticalSection crit_; + std::map> map_ GUARDED_BY(crit_); + + RTC_DISALLOW_COPY_AND_ASSIGN(RtcHistogramMap); +}; + +// RtcHistogramMap is allocated upon call to Enable(). +// The histogram getter functions, which return pointer values to the histograms +// in the map, are cached in WebRTC. Therefore, this memory is not freed by the +// application (the memory will be reclaimed by the OS). +static RtcHistogramMap* volatile g_rtc_histogram_map = nullptr; + +void CreateMap() { + RtcHistogramMap* map = rtc::AtomicOps::AcquireLoadPtr(&g_rtc_histogram_map); + if (map == nullptr) { + RtcHistogramMap* new_map = new RtcHistogramMap(); + RtcHistogramMap* old_map = rtc::AtomicOps::CompareAndSwapPtr( + &g_rtc_histogram_map, static_cast(nullptr), new_map); + if (old_map != nullptr) + delete new_map; + } +} + +// Set the first time we start using histograms. Used to make sure Enable() is +// not called thereafter. +#if RTC_DCHECK_IS_ON +static volatile int g_rtc_histogram_called = 0; +#endif + +// Gets the map (or nullptr). +RtcHistogramMap* GetMap() { +#if RTC_DCHECK_IS_ON + rtc::AtomicOps::ReleaseStore(&g_rtc_histogram_called, 1); +#endif + return g_rtc_histogram_map; +} +} // namespace + +// Implementation of histogram methods in +// webrtc/system_wrappers/interface/metrics.h. + +// Histogram with exponentially spaced buckets. +// Creates (or finds) histogram. +// The returned histogram pointer is cached (and used for adding samples in +// subsequent calls). +Histogram* HistogramFactoryGetCounts(const std::string& name, + int min, + int max, + int bucket_count) { + RtcHistogramMap* map = GetMap(); + if (!map) + return nullptr; + + return map->GetCountsHistogram(name, min, max, bucket_count); +} + +// Histogram with linearly spaced buckets. +// Creates (or finds) histogram. +// The returned histogram pointer is cached (and used for adding samples in +// subsequent calls). Histogram* HistogramFactoryGetEnumeration(const std::string& name, - int boundary) { return NULL; } + int boundary) { + RtcHistogramMap* map = GetMap(); + if (!map) + return nullptr; -void HistogramAdd( - Histogram* histogram_pointer, const std::string& name, int sample) {} + return map->GetEnumerationHistogram(name, boundary); +} + +// Fast path. Adds |sample| to cached |histogram_pointer|. +void HistogramAdd(Histogram* histogram_pointer, + const std::string& name, + int sample) { + if (!histogram_pointer) + return; + + RtcHistogram* ptr = reinterpret_cast(histogram_pointer); + RTC_DCHECK_EQ(name, ptr->name()) << "The name should not vary."; + ptr->Add(sample); +} + +SampleInfo::SampleInfo(const std::string& name, + int min, + int max, + size_t bucket_count) + : name(name), min(min), max(max), bucket_count(bucket_count) {} + +SampleInfo::~SampleInfo() {} + +// Implementation of global functions in metrics_default.h. +void Enable() { + RTC_DCHECK(g_rtc_histogram_map == nullptr); +#if RTC_DCHECK_IS_ON + RTC_DCHECK_EQ(0, rtc::AtomicOps::AcquireLoad(&g_rtc_histogram_called)); +#endif + CreateMap(); +} + +void GetAndReset( + std::map>* histograms) { + histograms->clear(); + RtcHistogramMap* map = GetMap(); + if (map) + map->GetAndReset(histograms); +} + +void Reset() { + RtcHistogramMap* map = GetMap(); + if (map) + map->Reset(); +} + +int NumEvents(const std::string& name, int sample) { + RtcHistogramMap* map = GetMap(); + return map ? map->NumEvents(name, sample) : 0; +} + +int NumSamples(const std::string& name) { + RtcHistogramMap* map = GetMap(); + return map ? map->NumSamples(name) : 0; +} + +int MinSample(const std::string& name) { + RtcHistogramMap* map = GetMap(); + return map ? map->MinSample(name) : -1; +} } // namespace metrics } // namespace webrtc - diff --git a/webrtc/system_wrappers/source/metrics_default_unittest.cc b/webrtc/system_wrappers/source/metrics_default_unittest.cc new file mode 100644 index 0000000000..c130a8c93e --- /dev/null +++ b/webrtc/system_wrappers/source/metrics_default_unittest.cc @@ -0,0 +1,154 @@ +/* + * Copyright (c) 2016 The WebRTC project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +#include "testing/gtest/include/gtest/gtest.h" + +#include "webrtc/system_wrappers/include/metrics.h" +#include "webrtc/system_wrappers/include/metrics_default.h" + +namespace webrtc { + +namespace { +const int kSample = 22; +const char kName[] = "Name"; + +int NumSamples( + const std::string& name, + const std::map>& + histograms) { + const auto it = histograms.find(name); + if (it == histograms.end()) + return 0; + + int num_samples = 0; + for (const auto& sample : it->second->samples) + num_samples += sample.second; + + return num_samples; +} + +int NumEvents(const std::string& name, + int sample, + const std::map>& + histograms) { + const auto it = histograms.find(name); + if (it == histograms.end()) + return 0; + + const auto it_sample = it->second->samples.find(sample); + if (it_sample == it->second->samples.end()) + return 0; + + return it_sample->second; +} +} // namespace + +class MetricsDefaultTest : public ::testing::Test { + public: + MetricsDefaultTest() {} + + protected: + virtual void SetUp() { + metrics::Reset(); + } +}; + +TEST_F(MetricsDefaultTest, Reset) { + RTC_HISTOGRAM_PERCENTAGE(kName, kSample); + EXPECT_EQ(1, metrics::NumSamples(kName)); + metrics::Reset(); + EXPECT_EQ(0, metrics::NumSamples(kName)); +} + +TEST_F(MetricsDefaultTest, NumSamples) { + RTC_HISTOGRAM_PERCENTAGE(kName, 5); + RTC_HISTOGRAM_PERCENTAGE(kName, 5); + RTC_HISTOGRAM_PERCENTAGE(kName, 10); + EXPECT_EQ(3, metrics::NumSamples(kName)); + EXPECT_EQ(0, metrics::NumSamples("NonExisting")); +} + +TEST_F(MetricsDefaultTest, NumEvents) { + RTC_HISTOGRAM_PERCENTAGE(kName, 5); + RTC_HISTOGRAM_PERCENTAGE(kName, 5); + RTC_HISTOGRAM_PERCENTAGE(kName, 10); + EXPECT_EQ(2, metrics::NumEvents(kName, 5)); + EXPECT_EQ(1, metrics::NumEvents(kName, 10)); + EXPECT_EQ(0, metrics::NumEvents(kName, 11)); + EXPECT_EQ(0, metrics::NumEvents("NonExisting", 5)); +} + +TEST_F(MetricsDefaultTest, MinSample) { + RTC_HISTOGRAM_PERCENTAGE(kName, kSample); + RTC_HISTOGRAM_PERCENTAGE(kName, kSample + 1); + EXPECT_EQ(kSample, metrics::MinSample(kName)); + EXPECT_EQ(-1, metrics::MinSample("NonExisting")); +} + +TEST_F(MetricsDefaultTest, Overflow) { + const std::string kName = "Overflow"; + // Samples should end up in overflow bucket. + RTC_HISTOGRAM_PERCENTAGE(kName, 101); + EXPECT_EQ(1, metrics::NumSamples(kName)); + EXPECT_EQ(1, metrics::NumEvents(kName, 101)); + RTC_HISTOGRAM_PERCENTAGE(kName, 102); + EXPECT_EQ(2, metrics::NumSamples(kName)); + EXPECT_EQ(2, metrics::NumEvents(kName, 101)); +} + +TEST_F(MetricsDefaultTest, Underflow) { + const std::string kName = "Underflow"; + // Samples should end up in underflow bucket. + RTC_HISTOGRAM_COUNTS_10000(kName, 0); + EXPECT_EQ(1, metrics::NumSamples(kName)); + EXPECT_EQ(1, metrics::NumEvents(kName, 0)); + RTC_HISTOGRAM_COUNTS_10000(kName, -1); + EXPECT_EQ(2, metrics::NumSamples(kName)); + EXPECT_EQ(2, metrics::NumEvents(kName, 0)); +} + +TEST_F(MetricsDefaultTest, GetAndReset) { + std::map> histograms; + metrics::GetAndReset(&histograms); + EXPECT_EQ(0u, histograms.size()); + RTC_HISTOGRAM_PERCENTAGE("Histogram1", 4); + RTC_HISTOGRAM_PERCENTAGE("Histogram1", 5); + RTC_HISTOGRAM_PERCENTAGE("Histogram1", 5); + RTC_HISTOGRAM_PERCENTAGE("Histogram2", 10); + EXPECT_EQ(3, metrics::NumSamples("Histogram1")); + EXPECT_EQ(1, metrics::NumSamples("Histogram2")); + + metrics::GetAndReset(&histograms); + EXPECT_EQ(2u, histograms.size()); + EXPECT_EQ(0, metrics::NumSamples("Histogram1")); + EXPECT_EQ(0, metrics::NumSamples("Histogram2")); + + EXPECT_EQ(3, NumSamples("Histogram1", histograms)); + EXPECT_EQ(1, NumSamples("Histogram2", histograms)); + EXPECT_EQ(1, NumEvents("Histogram1", 4, histograms)); + EXPECT_EQ(2, NumEvents("Histogram1", 5, histograms)); + EXPECT_EQ(1, NumEvents("Histogram2", 10, histograms)); +} + +TEST_F(MetricsDefaultTest, TestMinMaxBucket) { + const std::string kName = "MinMaxCounts100"; + RTC_HISTOGRAM_COUNTS_100(kName, 4); + + std::map> histograms; + metrics::GetAndReset(&histograms); + EXPECT_EQ(1u, histograms.size()); + EXPECT_EQ(kName, histograms.begin()->second->name); + EXPECT_EQ(1, histograms.begin()->second->min); + EXPECT_EQ(100, histograms.begin()->second->max); + EXPECT_EQ(50u, histograms.begin()->second->bucket_count); + EXPECT_EQ(1u, histograms.begin()->second->samples.size()); +} + +} // namespace webrtc diff --git a/webrtc/system_wrappers/source/metrics_unittest.cc b/webrtc/system_wrappers/source/metrics_unittest.cc index 7de6f5e6ee..1d7888fbbd 100644 --- a/webrtc/system_wrappers/source/metrics_unittest.cc +++ b/webrtc/system_wrappers/source/metrics_unittest.cc @@ -11,12 +11,11 @@ #include "testing/gtest/include/gtest/gtest.h" #include "webrtc/system_wrappers/include/metrics.h" -#include "webrtc/test/histogram.h" +#include "webrtc/system_wrappers/include/metrics_default.h" namespace webrtc { namespace { const int kSample = 22; -const std::string kName = "Name"; void AddSparseSample(const std::string& name, int sample) { RTC_HISTOGRAM_COUNTS_SPARSE_100(name, sample); @@ -24,92 +23,98 @@ void AddSparseSample(const std::string& name, int sample) { void AddSampleWithVaryingName(int index, const std::string& name, int sample) { RTC_HISTOGRAMS_COUNTS_100(index, name, sample); } -#if GTEST_HAS_DEATH_TEST && !defined(WEBRTC_ANDROID) +#if RTC_DCHECK_IS_ON && GTEST_HAS_DEATH_TEST && !defined(WEBRTC_ANDROID) void AddSample(const std::string& name, int sample) { RTC_HISTOGRAM_COUNTS_100(name, sample); } -#endif // GTEST_HAS_DEATH_TEST && !defined(WEBRTC_ANDROID) +#endif // RTC_DCHECK_IS_ON && GTEST_HAS_DEATH_TEST && !defined(WEBRTC_ANDROID) } // namespace -TEST(MetricsTest, InitiallyNoSamples) { - test::ClearHistograms(); - EXPECT_EQ(0, test::NumHistogramSamples(kName)); - EXPECT_EQ(-1, test::LastHistogramSample(kName)); -} +class MetricsTest : public ::testing::Test { + public: + MetricsTest() {} -TEST(MetricsTest, RtcHistogramPercent_AddSample) { - test::ClearHistograms(); - RTC_HISTOGRAM_PERCENTAGE(kName, kSample); - EXPECT_EQ(1, test::NumHistogramSamples(kName)); - EXPECT_EQ(kSample, test::LastHistogramSample(kName)); -} - -TEST(MetricsTest, RtcHistogramEnumeration_AddSample) { - test::ClearHistograms(); - RTC_HISTOGRAM_ENUMERATION(kName, kSample, kSample + 1); - EXPECT_EQ(1, test::NumHistogramSamples(kName)); - EXPECT_EQ(kSample, test::LastHistogramSample(kName)); -} - -TEST(MetricsTest, RtcHistogramCountsSparse_AddSample) { - test::ClearHistograms(); - RTC_HISTOGRAM_COUNTS_SPARSE_100(kName, kSample); - EXPECT_EQ(1, test::NumHistogramSamples(kName)); - EXPECT_EQ(kSample, test::LastHistogramSample(kName)); -} - -TEST(MetricsTest, RtcHistogramCounts_AddSample) { - test::ClearHistograms(); - RTC_HISTOGRAM_COUNTS_100(kName, kSample); - EXPECT_EQ(1, test::NumHistogramSamples(kName)); - EXPECT_EQ(kSample, test::LastHistogramSample(kName)); -} - -TEST(MetricsTest, RtcHistogramCounts_AddMultipleSamples) { - test::ClearHistograms(); - const int kNumSamples = 10; - for (int i = 0; i < kNumSamples; ++i) { - RTC_HISTOGRAM_COUNTS_100(kName, i); + protected: + virtual void SetUp() { + metrics::Reset(); } - EXPECT_EQ(kNumSamples, test::NumHistogramSamples(kName)); - EXPECT_EQ(kNumSamples - 1, test::LastHistogramSample(kName)); +}; + +TEST_F(MetricsTest, InitiallyNoSamples) { + EXPECT_EQ(0, metrics::NumSamples("NonExisting")); + EXPECT_EQ(0, metrics::NumEvents("NonExisting", kSample)); } -TEST(MetricsTest, RtcHistogramsCounts_AddSample) { - test::ClearHistograms(); +TEST_F(MetricsTest, RtcHistogramPercent_AddSample) { + const std::string kName = "Percentage"; + RTC_HISTOGRAM_PERCENTAGE(kName, kSample); + EXPECT_EQ(1, metrics::NumSamples(kName)); + EXPECT_EQ(1, metrics::NumEvents(kName, kSample)); +} + +TEST_F(MetricsTest, RtcHistogramEnumeration_AddSample) { + const std::string kName = "Enumeration"; + RTC_HISTOGRAM_ENUMERATION(kName, kSample, kSample + 1); + EXPECT_EQ(1, metrics::NumSamples(kName)); + EXPECT_EQ(1, metrics::NumEvents(kName, kSample)); +} + +TEST_F(MetricsTest, RtcHistogramCountsSparse_AddSample) { + const std::string kName = "CountsSparse100"; + RTC_HISTOGRAM_COUNTS_SPARSE_100(kName, kSample); + EXPECT_EQ(1, metrics::NumSamples(kName)); + EXPECT_EQ(1, metrics::NumEvents(kName, kSample)); +} + +TEST_F(MetricsTest, RtcHistogramCounts_AddSample) { + const std::string kName = "Counts100"; + RTC_HISTOGRAM_COUNTS_100(kName, kSample); + EXPECT_EQ(1, metrics::NumSamples(kName)); + EXPECT_EQ(1, metrics::NumEvents(kName, kSample)); +} + +TEST_F(MetricsTest, RtcHistogramCounts_AddMultipleSamples) { + const std::string kName = "Counts200"; + const int kNumSamples = 10; + for (int i = 1; i <= kNumSamples; ++i) { + RTC_HISTOGRAM_COUNTS_200(kName, i); + EXPECT_EQ(1, metrics::NumEvents(kName, i)); + EXPECT_EQ(i, metrics::NumSamples(kName)); + } +} + +TEST_F(MetricsTest, RtcHistogramsCounts_AddSample) { AddSampleWithVaryingName(0, "Name1", kSample); AddSampleWithVaryingName(1, "Name2", kSample + 1); AddSampleWithVaryingName(2, "Name3", kSample + 2); - EXPECT_EQ(1, test::NumHistogramSamples("Name1")); - EXPECT_EQ(1, test::NumHistogramSamples("Name2")); - EXPECT_EQ(1, test::NumHistogramSamples("Name3")); - EXPECT_EQ(kSample + 0, test::LastHistogramSample("Name1")); - EXPECT_EQ(kSample + 1, test::LastHistogramSample("Name2")); - EXPECT_EQ(kSample + 2, test::LastHistogramSample("Name3")); + EXPECT_EQ(1, metrics::NumSamples("Name1")); + EXPECT_EQ(1, metrics::NumSamples("Name2")); + EXPECT_EQ(1, metrics::NumSamples("Name3")); + EXPECT_EQ(1, metrics::NumEvents("Name1", kSample + 0)); + EXPECT_EQ(1, metrics::NumEvents("Name2", kSample + 1)); + EXPECT_EQ(1, metrics::NumEvents("Name3", kSample + 2)); } #if RTC_DCHECK_IS_ON && GTEST_HAS_DEATH_TEST && !defined(WEBRTC_ANDROID) -TEST(MetricsTest, RtcHistogramsCounts_InvalidIndex) { - EXPECT_DEATH(RTC_HISTOGRAMS_COUNTS_1000(-1, kName, kSample), ""); - EXPECT_DEATH(RTC_HISTOGRAMS_COUNTS_1000(3, kName, kSample), ""); - EXPECT_DEATH(RTC_HISTOGRAMS_COUNTS_1000(3u, kName, kSample), ""); +TEST_F(MetricsTest, RtcHistogramsCounts_InvalidIndex) { + EXPECT_DEATH(RTC_HISTOGRAMS_COUNTS_1000(-1, "Name", kSample), ""); + EXPECT_DEATH(RTC_HISTOGRAMS_COUNTS_1000(3, "Name", kSample), ""); + EXPECT_DEATH(RTC_HISTOGRAMS_COUNTS_1000(3u, "Name", kSample), ""); } #endif -TEST(MetricsTest, RtcHistogramSparse_NonConstantNameWorks) { - test::ClearHistograms(); - AddSparseSample("Name1", kSample); - AddSparseSample("Name2", kSample); - EXPECT_EQ(1, test::NumHistogramSamples("Name1")); - EXPECT_EQ(1, test::NumHistogramSamples("Name2")); +TEST_F(MetricsTest, RtcHistogramSparse_NonConstantNameWorks) { + AddSparseSample("Sparse1", kSample); + AddSparseSample("Sparse2", kSample); + EXPECT_EQ(1, metrics::NumSamples("Sparse1")); + EXPECT_EQ(1, metrics::NumSamples("Sparse2")); } -#if GTEST_HAS_DEATH_TEST && !defined(WEBRTC_ANDROID) -TEST(MetricsTest, RtcHistogram_FailsForNonConstantName) { - test::ClearHistograms(); - AddSample("Name1", kSample); - EXPECT_DEATH(AddSample("Name2", kSample), ""); +#if RTC_DCHECK_IS_ON && GTEST_HAS_DEATH_TEST && !defined(WEBRTC_ANDROID) +TEST_F(MetricsTest, RtcHistogram_FailsForNonConstantName) { + AddSample("ConstantName1", kSample); + EXPECT_DEATH(AddSample("NotConstantName1", kSample), ""); } -#endif // GTEST_HAS_DEATH_TEST && !defined(WEBRTC_ANDROID) +#endif } // namespace webrtc diff --git a/webrtc/system_wrappers/system_wrappers.gyp b/webrtc/system_wrappers/system_wrappers.gyp index b61ecf28ee..d46ec82b59 100644 --- a/webrtc/system_wrappers/system_wrappers.gyp +++ b/webrtc/system_wrappers/system_wrappers.gyp @@ -180,6 +180,7 @@ 'target_name': 'metrics_default', 'type': 'static_library', 'sources': [ + 'include/metrics_default.h', 'source/metrics_default.cc', ], }, { diff --git a/webrtc/system_wrappers/system_wrappers_tests.gyp b/webrtc/system_wrappers/system_wrappers_tests.gyp index 174c96c948..520ea4d00b 100644 --- a/webrtc/system_wrappers/system_wrappers_tests.gyp +++ b/webrtc/system_wrappers/system_wrappers_tests.gyp @@ -14,8 +14,8 @@ 'type': '<(gtest_target_type)', 'dependencies': [ '<(DEPTH)/testing/gtest.gyp:gtest', + '<(webrtc_root)/system_wrappers/system_wrappers.gyp:metrics_default', '<(webrtc_root)/system_wrappers/system_wrappers.gyp:system_wrappers', - '<(webrtc_root)/test/test.gyp:histogram', '<(webrtc_root)/test/test.gyp:test_support_main', ], 'sources': [ @@ -31,6 +31,7 @@ 'source/data_log_c_helpers_unittest.c', 'source/data_log_c_helpers_unittest.h', 'source/event_timer_posix_unittest.cc', + 'source/metrics_default_unittest.cc', 'source/metrics_unittest.cc', 'source/ntp_time_unittest.cc', 'source/rtp_to_ntp_unittest.cc', diff --git a/webrtc/test/BUILD.gn b/webrtc/test/BUILD.gn index af9516f434..5951693a50 100644 --- a/webrtc/test/BUILD.gn +++ b/webrtc/test/BUILD.gn @@ -34,21 +34,6 @@ source_set("field_trial") { public_configs = [ "..:common_inherited_config" ] } -source_set("histogram") { - sources = [ - "histogram.cc", - "histogram.h", - ] - - deps = [ - "..:webrtc_common", - "../system_wrappers", - ] - - configs += [ "..:common_config" ] - public_configs = [ "..:common_inherited_config" ] -} - source_set("test_support") { testonly = true @@ -100,8 +85,8 @@ source_set("test_support_main") { deps = [ ":field_trial", - ":histogram", ":test_support", + "../system_wrappers:metrics_default", "//testing/gmock", "//testing/gtest", "//third_party/gflags", diff --git a/webrtc/test/histogram.cc b/webrtc/test/histogram.cc deleted file mode 100644 index 2893e4389a..0000000000 --- a/webrtc/test/histogram.cc +++ /dev/null @@ -1,97 +0,0 @@ -/* - * Copyright (c) 2015 The WebRTC project authors. All Rights Reserved. - * - * Use of this source code is governed by a BSD-style license - * that can be found in the LICENSE file in the root of the source - * tree. An additional intellectual property rights grant can be found - * in the file PATENTS. All contributing project authors may - * be found in the AUTHORS file in the root of the source tree. - */ - -#include "webrtc/test/histogram.h" - -#include - -#include "webrtc/base/checks.h" -#include "webrtc/base/criticalsection.h" -#include "webrtc/base/thread_annotations.h" -#include "webrtc/system_wrappers/include/metrics.h" - -// Test implementation of histogram methods in -// webrtc/system_wrappers/include/metrics.h. - -namespace webrtc { -namespace { -struct SampleInfo { - SampleInfo(const std::string& name) : name_(name), last_(-1), total_(0) {} - const std::string name_; - int last_; // Last added sample. - int total_; // Total number of added samples. -}; - -rtc::CriticalSection histogram_crit_; -// Map holding info about added samples to a histogram (mapped by the histogram -// name). -std::map histograms_ GUARDED_BY(histogram_crit_); -} // namespace - -namespace metrics { -Histogram* HistogramFactoryGetCounts(const std::string& name, int min, int max, - int bucket_count) { - rtc::CritScope cs(&histogram_crit_); - if (histograms_.find(name) == histograms_.end()) { - histograms_.insert(std::make_pair(name, SampleInfo(name))); - } - auto it = histograms_.find(name); - return reinterpret_cast(&it->second); -} - -Histogram* HistogramFactoryGetEnumeration(const std::string& name, - int boundary) { - rtc::CritScope cs(&histogram_crit_); - if (histograms_.find(name) == histograms_.end()) { - histograms_.insert(std::make_pair(name, SampleInfo(name))); - } - auto it = histograms_.find(name); - return reinterpret_cast(&it->second); -} - -void HistogramAdd( - Histogram* histogram_pointer, const std::string& name, int sample) { - rtc::CritScope cs(&histogram_crit_); - SampleInfo* ptr = reinterpret_cast(histogram_pointer); - // The name should not vary. - RTC_CHECK(ptr->name_ == name); - ptr->last_ = sample; - ++ptr->total_; -} -} // namespace metrics - -namespace test { -int LastHistogramSample(const std::string& name) { - rtc::CritScope cs(&histogram_crit_); - const auto it = histograms_.find(name); - if (it == histograms_.end()) { - return -1; - } - return it->second.last_; -} - -int NumHistogramSamples(const std::string& name) { - rtc::CritScope cs(&histogram_crit_); - const auto it = histograms_.find(name); - if (it == histograms_.end()) { - return 0; - } - return it->second.total_; -} - -void ClearHistograms() { - rtc::CritScope cs(&histogram_crit_); - for (auto& it : histograms_) { - it.second.last_ = -1; - it.second.total_ = 0; - } -} -} // namespace test -} // namespace webrtc diff --git a/webrtc/test/histogram.h b/webrtc/test/histogram.h deleted file mode 100644 index 3c8e743aa1..0000000000 --- a/webrtc/test/histogram.h +++ /dev/null @@ -1,33 +0,0 @@ -/* - * Copyright (c) 2015 The WebRTC project authors. All Rights Reserved. - * - * Use of this source code is governed by a BSD-style license - * that can be found in the LICENSE file in the root of the source - * tree. An additional intellectual property rights grant can be found - * in the file PATENTS. All contributing project authors may - * be found in the AUTHORS file in the root of the source tree. - */ - -#ifndef WEBRTC_TEST_HISTOGRAM_H_ -#define WEBRTC_TEST_HISTOGRAM_H_ - -#include - -namespace webrtc { -namespace test { - -// Returns the last added sample to a histogram (or -1 if the histogram is not -// found). -int LastHistogramSample(const std::string& name); - -// Returns the number of added samples to a histogram. -int NumHistogramSamples(const std::string& name); - -// Removes all histogram samples. -void ClearHistograms(); - -} // namespace test -} // namespace webrtc - -#endif // WEBRTC_TEST_HISTOGRAM_H_ - diff --git a/webrtc/test/test.gyp b/webrtc/test/test.gyp index a04a128a0e..ac52e59f79 100644 --- a/webrtc/test/test.gyp +++ b/webrtc/test/test.gyp @@ -106,18 +106,6 @@ '<(webrtc_root)/system_wrappers/system_wrappers.gyp:system_wrappers', ], }, - { - 'target_name': 'histogram', - 'type': 'static_library', - 'sources': [ - 'histogram.cc', - 'histogram.h', - ], - 'dependencies': [ - '<(webrtc_root)/common.gyp:webrtc_common', - '<(webrtc_root)/system_wrappers/system_wrappers.gyp:system_wrappers', - ], - }, { 'target_name': 'test_main', 'type': 'static_library', @@ -126,10 +114,10 @@ ], 'dependencies': [ 'field_trial', - 'histogram', 'test_support', '<(DEPTH)/testing/gtest.gyp:gtest', '<(DEPTH)/third_party/gflags/gflags.gyp:gflags', + '<(webrtc_root)/system_wrappers/system_wrappers.gyp:metrics_default', ], }, { @@ -178,11 +166,11 @@ 'type': 'static_library', 'dependencies': [ 'field_trial', - 'histogram', 'test_support', '<(DEPTH)/testing/gmock.gyp:gmock', '<(DEPTH)/testing/gtest.gyp:gtest', '<(DEPTH)/third_party/gflags/gflags.gyp:gflags', + '<(webrtc_root)/system_wrappers/system_wrappers.gyp:metrics_default', ], 'sources': [ 'run_all_unittests.cc', diff --git a/webrtc/test/test_main.cc b/webrtc/test/test_main.cc index a435575f88..a92ad9f5e6 100644 --- a/webrtc/test/test_main.cc +++ b/webrtc/test/test_main.cc @@ -11,6 +11,7 @@ #include "gflags/gflags.h" #include "testing/gtest/include/gtest/gtest.h" #include "webrtc/base/logging.h" +#include "webrtc/system_wrappers/include/metrics_default.h" #include "webrtc/test/field_trial.h" #include "webrtc/test/testsupport/fileutils.h" @@ -34,5 +35,6 @@ int main(int argc, char* argv[]) { webrtc::test::SetExecutablePath(argv[0]); webrtc::test::InitFieldTrialsFromString(FLAGS_force_fieldtrials); + webrtc::metrics::Enable(); return RUN_ALL_TESTS(); } diff --git a/webrtc/test/test_suite.cc b/webrtc/test/test_suite.cc index 2900f0eddb..69e4a57508 100644 --- a/webrtc/test/test_suite.cc +++ b/webrtc/test/test_suite.cc @@ -14,6 +14,7 @@ #include "testing/gmock/include/gmock/gmock.h" #include "testing/gtest/include/gtest/gtest.h" #include "webrtc/base/logging.h" +#include "webrtc/system_wrappers/include/metrics_default.h" #include "webrtc/test/testsupport/fileutils.h" #include "webrtc/test/testsupport/trace_to_stderr.h" #include "webrtc/test/field_trial.h" @@ -37,6 +38,7 @@ TestSuite::TestSuite(int argc, char** argv) { google::ParseCommandLineFlags(&argc, &argv, true); webrtc::test::InitFieldTrialsFromString(FLAGS_force_fieldtrials); + webrtc::metrics::Enable(); } TestSuite::~TestSuite() { diff --git a/webrtc/video/call_stats_unittest.cc b/webrtc/video/call_stats_unittest.cc index 8b3cde07a8..f81a3a3eff 100644 --- a/webrtc/video/call_stats_unittest.cc +++ b/webrtc/video/call_stats_unittest.cc @@ -15,7 +15,7 @@ #include "webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h" #include "webrtc/system_wrappers/include/metrics.h" -#include "webrtc/test/histogram.h" +#include "webrtc/system_wrappers/include/metrics_default.h" #include "webrtc/video/call_stats.h" using ::testing::_; @@ -204,6 +204,7 @@ TEST_F(CallStatsTest, LastProcessedRtt) { } TEST_F(CallStatsTest, ProducesHistogramMetrics) { + metrics::Reset(); const int64_t kRtt = 123; RtcpRttStats* rtcp_rtt_stats = call_stats_->rtcp_rtt_stats(); rtcp_rtt_stats->OnRttUpdate(kRtt); @@ -212,10 +213,10 @@ TEST_F(CallStatsTest, ProducesHistogramMetrics) { call_stats_->Process(); call_stats_.reset(); - EXPECT_EQ(1, test::NumHistogramSamples( + EXPECT_EQ(1, metrics::NumSamples( "WebRTC.Video.AverageRoundTripTimeInMilliseconds")); - EXPECT_EQ(kRtt, test::LastHistogramSample( - "WebRTC.Video.AverageRoundTripTimeInMilliseconds")); + EXPECT_EQ(1, metrics::NumEvents( + "WebRTC.Video.AverageRoundTripTimeInMilliseconds", kRtt)); } } // namespace webrtc diff --git a/webrtc/video/end_to_end_tests.cc b/webrtc/video/end_to_end_tests.cc index b60d2a629a..607d654c92 100644 --- a/webrtc/video/end_to_end_tests.cc +++ b/webrtc/video/end_to_end_tests.cc @@ -31,6 +31,7 @@ #include "webrtc/modules/video_coding/codecs/vp9/include/vp9.h" #include "webrtc/modules/video_coding/include/video_coding_defines.h" #include "webrtc/system_wrappers/include/metrics.h" +#include "webrtc/system_wrappers/include/metrics_default.h" #include "webrtc/system_wrappers/include/sleep.h" #include "webrtc/test/call_test.h" #include "webrtc/test/direct_transport.h" @@ -39,7 +40,6 @@ #include "webrtc/test/fake_encoder.h" #include "webrtc/test/frame_generator.h" #include "webrtc/test/frame_generator_capturer.h" -#include "webrtc/test/histogram.h" #include "webrtc/test/null_transport.h" #include "webrtc/test/rtcp_packet_parser.h" #include "webrtc/test/rtp_rtcp_observer.h" @@ -1979,17 +1979,14 @@ TEST_F(EndToEndTest, VerifyNackStats) { int64_t start_runtime_ms_; } test; - test::ClearHistograms(); + metrics::Reset(); RunBaseTest(&test); - EXPECT_EQ(1, test::NumHistogramSamples( - "WebRTC.Video.UniqueNackRequestsSentInPercent")); - EXPECT_EQ(1, test::NumHistogramSamples( - "WebRTC.Video.UniqueNackRequestsReceivedInPercent")); - EXPECT_GT(test::LastHistogramSample( - "WebRTC.Video.NackPacketsSentPerMinute"), 0); - EXPECT_GT(test::LastHistogramSample( - "WebRTC.Video.NackPacketsReceivedPerMinute"), 0); + EXPECT_EQ( + 1, metrics::NumSamples("WebRTC.Video.UniqueNackRequestsSentInPercent")); + EXPECT_EQ(1, metrics::NumSamples( + "WebRTC.Video.UniqueNackRequestsReceivedInPercent")); + EXPECT_GT(metrics::MinSample("WebRTC.Video.NackPacketsSentPerMinute"), 0); } void EndToEndTest::VerifyHistogramStats(bool use_rtx, @@ -2077,7 +2074,7 @@ void EndToEndTest::VerifyHistogramStats(bool use_rtx, int64_t start_runtime_ms_; } test(use_rtx, use_red, screenshare); - test::ClearHistograms(); + metrics::Reset(); RunBaseTest(&test); // Delete the call for Call stats to be reported. @@ -2088,110 +2085,99 @@ void EndToEndTest::VerifyHistogramStats(bool use_rtx, screenshare ? "WebRTC.Video.Screenshare." : "WebRTC.Video."; // Verify that stats have been updated once. - EXPECT_EQ( - 1, test::NumHistogramSamples("WebRTC.Call.VideoBitrateReceivedInKbps")); + EXPECT_EQ(1, metrics::NumSamples("WebRTC.Call.VideoBitrateReceivedInKbps")); + EXPECT_EQ(1, metrics::NumSamples("WebRTC.Call.RtcpBitrateReceivedInBps")); + EXPECT_EQ(1, metrics::NumSamples("WebRTC.Call.BitrateReceivedInKbps")); + EXPECT_EQ(1, metrics::NumSamples("WebRTC.Call.EstimatedSendBitrateInKbps")); + EXPECT_EQ(1, metrics::NumSamples("WebRTC.Call.PacerBitrateInKbps")); + + EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.NackPacketsSentPerMinute")); EXPECT_EQ(1, - test::NumHistogramSamples("WebRTC.Call.RtcpBitrateReceivedInBps")); - EXPECT_EQ(1, test::NumHistogramSamples("WebRTC.Call.BitrateReceivedInKbps")); - EXPECT_EQ( - 1, test::NumHistogramSamples("WebRTC.Call.EstimatedSendBitrateInKbps")); - EXPECT_EQ(1, test::NumHistogramSamples("WebRTC.Call.PacerBitrateInKbps")); - - EXPECT_EQ(1, test::NumHistogramSamples( - "WebRTC.Video.NackPacketsSentPerMinute")); - EXPECT_EQ(1, test::NumHistogramSamples(video_prefix + - "NackPacketsReceivedPerMinute")); - EXPECT_EQ(1, test::NumHistogramSamples( - "WebRTC.Video.FirPacketsSentPerMinute")); - EXPECT_EQ(1, test::NumHistogramSamples(video_prefix + - "FirPacketsReceivedPerMinute")); - EXPECT_EQ(1, test::NumHistogramSamples( - "WebRTC.Video.PliPacketsSentPerMinute")); - EXPECT_EQ(1, test::NumHistogramSamples(video_prefix + - "PliPacketsReceivedPerMinute")); - - EXPECT_EQ( - 1, test::NumHistogramSamples(video_prefix + "KeyFramesSentInPermille")); - EXPECT_EQ(1, test::NumHistogramSamples( - "WebRTC.Video.KeyFramesReceivedInPermille")); - - EXPECT_EQ( - 1, test::NumHistogramSamples(video_prefix + "SentPacketsLostInPercent")); - EXPECT_EQ(1, test::NumHistogramSamples( - "WebRTC.Video.ReceivedPacketsLostInPercent")); - - EXPECT_EQ(1, test::NumHistogramSamples(video_prefix + "InputWidthInPixels")); - EXPECT_EQ(1, test::NumHistogramSamples(video_prefix + "InputHeightInPixels")); - EXPECT_EQ(1, test::NumHistogramSamples(video_prefix + "SentWidthInPixels")); - EXPECT_EQ(1, test::NumHistogramSamples(video_prefix + "SentHeightInPixels")); - EXPECT_EQ(1, test::NumHistogramSamples("WebRTC.Video.ReceivedWidthInPixels")); + metrics::NumSamples(video_prefix + "NackPacketsReceivedPerMinute")); + EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.FirPacketsSentPerMinute")); EXPECT_EQ(1, - test::NumHistogramSamples("WebRTC.Video.ReceivedHeightInPixels")); - - EXPECT_EQ(static_cast(video_encoder_config_.streams[0].width), - test::LastHistogramSample(video_prefix + "InputWidthInPixels")); - EXPECT_EQ(static_cast(video_encoder_config_.streams[0].height), - test::LastHistogramSample(video_prefix + "InputHeightInPixels")); - EXPECT_EQ(static_cast(video_encoder_config_.streams[0].width), - test::LastHistogramSample(video_prefix + "SentWidthInPixels")); - EXPECT_EQ(static_cast(video_encoder_config_.streams[0].height), - test::LastHistogramSample(video_prefix + "SentHeightInPixels")); - EXPECT_EQ(static_cast(video_encoder_config_.streams[0].width), - test::LastHistogramSample("WebRTC.Video.ReceivedWidthInPixels")); - EXPECT_EQ(static_cast(video_encoder_config_.streams[0].height), - test::LastHistogramSample("WebRTC.Video.ReceivedHeightInPixels")); - + metrics::NumSamples(video_prefix + "FirPacketsReceivedPerMinute")); + EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.PliPacketsSentPerMinute")); EXPECT_EQ(1, - test::NumHistogramSamples(video_prefix + "InputFramesPerSecond")); - EXPECT_EQ(1, test::NumHistogramSamples(video_prefix + "SentFramesPerSecond")); - EXPECT_EQ(1, test::NumHistogramSamples( - "WebRTC.Video.DecodedFramesPerSecond")); - EXPECT_EQ(1, test::NumHistogramSamples("WebRTC.Video.RenderFramesPerSecond")); + metrics::NumSamples(video_prefix + "PliPacketsReceivedPerMinute")); - EXPECT_EQ(1, test::NumHistogramSamples("WebRTC.Video.JitterBufferDelayInMs")); - EXPECT_EQ(1, test::NumHistogramSamples("WebRTC.Video.TargetDelayInMs")); - EXPECT_EQ(1, test::NumHistogramSamples("WebRTC.Video.CurrentDelayInMs")); - EXPECT_EQ(1, test::NumHistogramSamples("WebRTC.Video.OnewayDelayInMs")); + EXPECT_EQ(1, metrics::NumSamples(video_prefix + "KeyFramesSentInPermille")); + EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.KeyFramesReceivedInPermille")); + + EXPECT_EQ(1, metrics::NumSamples(video_prefix + "SentPacketsLostInPercent")); + EXPECT_EQ(1, + metrics::NumSamples("WebRTC.Video.ReceivedPacketsLostInPercent")); + + EXPECT_EQ(1, metrics::NumSamples(video_prefix + "InputWidthInPixels")); + EXPECT_EQ(1, metrics::NumSamples(video_prefix + "InputHeightInPixels")); + EXPECT_EQ(1, metrics::NumSamples(video_prefix + "SentWidthInPixels")); + EXPECT_EQ(1, metrics::NumSamples(video_prefix + "SentHeightInPixels")); + EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.ReceivedWidthInPixels")); + EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.ReceivedHeightInPixels")); + + EXPECT_EQ(1, metrics::NumEvents( + video_prefix + "InputWidthInPixels", + static_cast(video_encoder_config_.streams[0].width))); + EXPECT_EQ(1, metrics::NumEvents( + video_prefix + "InputHeightInPixels", + static_cast(video_encoder_config_.streams[0].height))); + EXPECT_EQ(1, metrics::NumEvents( + video_prefix + "SentWidthInPixels", + static_cast(video_encoder_config_.streams[0].width))); + EXPECT_EQ(1, metrics::NumEvents( + video_prefix + "SentHeightInPixels", + static_cast(video_encoder_config_.streams[0].height))); + EXPECT_EQ(1, metrics::NumEvents( + "WebRTC.Video.ReceivedWidthInPixels", + static_cast(video_encoder_config_.streams[0].width))); + EXPECT_EQ(1, metrics::NumEvents( + "WebRTC.Video.ReceivedHeightInPixels", + static_cast(video_encoder_config_.streams[0].height))); + + EXPECT_EQ(1, metrics::NumSamples(video_prefix + "InputFramesPerSecond")); + EXPECT_EQ(1, metrics::NumSamples(video_prefix + "SentFramesPerSecond")); + EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.DecodedFramesPerSecond")); + EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.RenderFramesPerSecond")); + + EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.JitterBufferDelayInMs")); + EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.TargetDelayInMs")); + EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.CurrentDelayInMs")); + EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.OnewayDelayInMs")); + + EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.RenderSqrtPixelsPerSecond")); + + EXPECT_EQ(1, metrics::NumSamples(video_prefix + "EncodeTimeInMs")); + EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.DecodeTimeInMs")); + + EXPECT_EQ(1, metrics::NumSamples(video_prefix + "BitrateSentInKbps")); + EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.BitrateReceivedInKbps")); + EXPECT_EQ(1, metrics::NumSamples(video_prefix + "MediaBitrateSentInKbps")); + EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.MediaBitrateReceivedInKbps")); + EXPECT_EQ(1, metrics::NumSamples(video_prefix + "PaddingBitrateSentInKbps")); + EXPECT_EQ(1, + metrics::NumSamples("WebRTC.Video.PaddingBitrateReceivedInKbps")); EXPECT_EQ( - 1, test::NumHistogramSamples("WebRTC.Video.RenderSqrtPixelsPerSecond")); + 1, metrics::NumSamples(video_prefix + "RetransmittedBitrateSentInKbps")); + EXPECT_EQ(1, metrics::NumSamples( + "WebRTC.Video.RetransmittedBitrateReceivedInKbps")); - EXPECT_EQ(1, test::NumHistogramSamples(video_prefix + "EncodeTimeInMs")); - EXPECT_EQ(1, test::NumHistogramSamples("WebRTC.Video.DecodeTimeInMs")); - - EXPECT_EQ(1, test::NumHistogramSamples(video_prefix + "BitrateSentInKbps")); - EXPECT_EQ(1, test::NumHistogramSamples( - "WebRTC.Video.BitrateReceivedInKbps")); - EXPECT_EQ(1, - test::NumHistogramSamples(video_prefix + "MediaBitrateSentInKbps")); - EXPECT_EQ(1, test::NumHistogramSamples( - "WebRTC.Video.MediaBitrateReceivedInKbps")); - EXPECT_EQ( - 1, test::NumHistogramSamples(video_prefix + "PaddingBitrateSentInKbps")); - EXPECT_EQ(1, test::NumHistogramSamples( - "WebRTC.Video.PaddingBitrateReceivedInKbps")); - EXPECT_EQ(1, test::NumHistogramSamples(video_prefix + - "RetransmittedBitrateSentInKbps")); - EXPECT_EQ(1, test::NumHistogramSamples( - "WebRTC.Video.RetransmittedBitrateReceivedInKbps")); - - EXPECT_EQ(1, test::NumHistogramSamples(video_prefix + "SendSideDelayInMs")); - EXPECT_EQ(1, - test::NumHistogramSamples(video_prefix + "SendSideDelayMaxInMs")); - EXPECT_EQ(1, test::NumHistogramSamples("WebRTC.Video.SendDelayInMs")); + EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.SendDelayInMs")); + EXPECT_EQ(1, metrics::NumSamples(video_prefix + "SendSideDelayInMs")); + EXPECT_EQ(1, metrics::NumSamples(video_prefix + "SendSideDelayMaxInMs")); int num_rtx_samples = use_rtx ? 1 : 0; - EXPECT_EQ(num_rtx_samples, test::NumHistogramSamples( - "WebRTC.Video.RtxBitrateSentInKbps")); - EXPECT_EQ(num_rtx_samples, test::NumHistogramSamples( - "WebRTC.Video.RtxBitrateReceivedInKbps")); + EXPECT_EQ(num_rtx_samples, + metrics::NumSamples("WebRTC.Video.RtxBitrateSentInKbps")); + EXPECT_EQ(num_rtx_samples, + metrics::NumSamples("WebRTC.Video.RtxBitrateReceivedInKbps")); int num_red_samples = use_red ? 1 : 0; - EXPECT_EQ(num_red_samples, test::NumHistogramSamples( - "WebRTC.Video.FecBitrateSentInKbps")); - EXPECT_EQ(num_red_samples, test::NumHistogramSamples( - "WebRTC.Video.FecBitrateReceivedInKbps")); - EXPECT_EQ(num_red_samples, test::NumHistogramSamples( - "WebRTC.Video.ReceivedFecPacketsInPercent")); + EXPECT_EQ(num_red_samples, + metrics::NumSamples("WebRTC.Video.FecBitrateSentInKbps")); + EXPECT_EQ(num_red_samples, + metrics::NumSamples("WebRTC.Video.FecBitrateReceivedInKbps")); + EXPECT_EQ(num_red_samples, + metrics::NumSamples("WebRTC.Video.ReceivedFecPacketsInPercent")); } TEST_F(EndToEndTest, VerifyHistogramStatsWithRtx) { diff --git a/webrtc/video/send_delay_stats_unittest.cc b/webrtc/video/send_delay_stats_unittest.cc index 44c62c3a45..7c60446232 100644 --- a/webrtc/video/send_delay_stats_unittest.cc +++ b/webrtc/video/send_delay_stats_unittest.cc @@ -12,7 +12,7 @@ #include "testing/gtest/include/gtest/gtest.h" #include "webrtc/system_wrappers/include/metrics.h" -#include "webrtc/test/histogram.h" +#include "webrtc/system_wrappers/include/metrics_default.h" namespace webrtc { namespace { @@ -102,7 +102,7 @@ TEST_F(SendDelayStatsTest, OldPacketsRemoved) { } TEST_F(SendDelayStatsTest, HistogramsAreUpdated) { - test::ClearHistograms(); + metrics::Reset(); const int64_t kDelayMs1 = 5; const int64_t kDelayMs2 = 10; uint16_t id = 0; @@ -115,8 +115,9 @@ TEST_F(SendDelayStatsTest, HistogramsAreUpdated) { EXPECT_TRUE(OnSentPacket(id)); } stats_.reset(); - EXPECT_EQ(2, test::NumHistogramSamples("WebRTC.Video.SendDelayInMs")); - EXPECT_EQ(kDelayMs2, test::LastHistogramSample("WebRTC.Video.SendDelayInMs")); + EXPECT_EQ(2, metrics::NumSamples("WebRTC.Video.SendDelayInMs")); + EXPECT_EQ(1, metrics::NumEvents("WebRTC.Video.SendDelayInMs", kDelayMs1)); + EXPECT_EQ(1, metrics::NumEvents("WebRTC.Video.SendDelayInMs", kDelayMs2)); } } // namespace webrtc diff --git a/webrtc/video/send_statistics_proxy_unittest.cc b/webrtc/video/send_statistics_proxy_unittest.cc index 636b9dc40c..2bf038d2c4 100644 --- a/webrtc/video/send_statistics_proxy_unittest.cc +++ b/webrtc/video/send_statistics_proxy_unittest.cc @@ -17,7 +17,7 @@ #include "testing/gtest/include/gtest/gtest.h" #include "webrtc/system_wrappers/include/metrics.h" -#include "webrtc/test/histogram.h" +#include "webrtc/system_wrappers/include/metrics_default.h" namespace webrtc { namespace { @@ -40,6 +40,7 @@ class SendStatisticsProxyTest : public ::testing::Test { protected: virtual void SetUp() { + metrics::Reset(); statistics_proxy_.reset(new SendStatisticsProxy( &fake_clock_, GetTestConfig(), VideoEncoderConfig::ContentType::kRealtimeVideo)); @@ -285,7 +286,6 @@ TEST_F(SendStatisticsProxyTest, OnEncodedFrameTimeMeasured) { } TEST_F(SendStatisticsProxyTest, SwitchContentTypeUpdatesHistograms) { - test::ClearHistograms(); const int kWidth = 640; const int kHeight = 480; @@ -295,15 +295,14 @@ TEST_F(SendStatisticsProxyTest, SwitchContentTypeUpdatesHistograms) { // No switch, stats not should be updated. statistics_proxy_->SetContentType( VideoEncoderConfig::ContentType::kRealtimeVideo); - EXPECT_EQ(0, test::NumHistogramSamples("WebRTC.Video.InputWidthInPixels")); + EXPECT_EQ(0, metrics::NumSamples("WebRTC.Video.InputWidthInPixels")); // Switch to screenshare, real-time stats should be updated. statistics_proxy_->SetContentType(VideoEncoderConfig::ContentType::kScreen); - EXPECT_EQ(1, test::NumHistogramSamples("WebRTC.Video.InputWidthInPixels")); + EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.InputWidthInPixels")); } TEST_F(SendStatisticsProxyTest, VerifyQpHistogramStats_Vp8) { - test::ClearHistograms(); EncodedImage encoded_image; CodecSpecificInfo codec_info; codec_info.codecType = kVideoCodecVP8; @@ -317,12 +316,10 @@ TEST_F(SendStatisticsProxyTest, VerifyQpHistogramStats_Vp8) { statistics_proxy_->OnSendEncodedImage(encoded_image, &codec_info); } statistics_proxy_.reset(); - EXPECT_EQ(1, test::NumHistogramSamples("WebRTC.Video.Encoded.Qp.Vp8.S0")); - EXPECT_EQ(kQpIdx0, - test::LastHistogramSample("WebRTC.Video.Encoded.Qp.Vp8.S0")); - EXPECT_EQ(1, test::NumHistogramSamples("WebRTC.Video.Encoded.Qp.Vp8.S1")); - EXPECT_EQ(kQpIdx1, - test::LastHistogramSample("WebRTC.Video.Encoded.Qp.Vp8.S1")); + EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.Encoded.Qp.Vp8.S0")); + EXPECT_EQ(1, metrics::NumEvents("WebRTC.Video.Encoded.Qp.Vp8.S0", kQpIdx0)); + EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.Encoded.Qp.Vp8.S1")); + EXPECT_EQ(1, metrics::NumEvents("WebRTC.Video.Encoded.Qp.Vp8.S1", kQpIdx1)); } TEST_F(SendStatisticsProxyTest, VerifyQpHistogramStats_Vp8OneSsrc) { @@ -331,7 +328,6 @@ TEST_F(SendStatisticsProxyTest, VerifyQpHistogramStats_Vp8OneSsrc) { statistics_proxy_.reset(new SendStatisticsProxy( &fake_clock_, config, VideoEncoderConfig::ContentType::kRealtimeVideo)); - test::ClearHistograms(); EncodedImage encoded_image; CodecSpecificInfo codec_info; codec_info.codecType = kVideoCodecVP8; @@ -342,12 +338,11 @@ TEST_F(SendStatisticsProxyTest, VerifyQpHistogramStats_Vp8OneSsrc) { statistics_proxy_->OnSendEncodedImage(encoded_image, &codec_info); } statistics_proxy_.reset(); - EXPECT_EQ(1, test::NumHistogramSamples("WebRTC.Video.Encoded.Qp.Vp8")); - EXPECT_EQ(kQpIdx0, test::LastHistogramSample("WebRTC.Video.Encoded.Qp.Vp8")); + EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.Encoded.Qp.Vp8")); + EXPECT_EQ(1, metrics::NumEvents("WebRTC.Video.Encoded.Qp.Vp8", kQpIdx0)); } TEST_F(SendStatisticsProxyTest, VerifyQpHistogramStats_Vp9) { - test::ClearHistograms(); EncodedImage encoded_image; CodecSpecificInfo codec_info; codec_info.codecType = kVideoCodecVP9; @@ -362,12 +357,10 @@ TEST_F(SendStatisticsProxyTest, VerifyQpHistogramStats_Vp9) { statistics_proxy_->OnSendEncodedImage(encoded_image, &codec_info); } statistics_proxy_.reset(); - EXPECT_EQ(1, test::NumHistogramSamples("WebRTC.Video.Encoded.Qp.Vp9.S0")); - EXPECT_EQ(kQpIdx0, - test::LastHistogramSample("WebRTC.Video.Encoded.Qp.Vp9.S0")); - EXPECT_EQ(1, test::NumHistogramSamples("WebRTC.Video.Encoded.Qp.Vp9.S1")); - EXPECT_EQ(kQpIdx1, - test::LastHistogramSample("WebRTC.Video.Encoded.Qp.Vp9.S1")); + EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.Encoded.Qp.Vp9.S0")); + EXPECT_EQ(1, metrics::NumEvents("WebRTC.Video.Encoded.Qp.Vp9.S0", kQpIdx0)); + EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.Encoded.Qp.Vp9.S1")); + EXPECT_EQ(1, metrics::NumEvents("WebRTC.Video.Encoded.Qp.Vp9.S1", kQpIdx1)); } TEST_F(SendStatisticsProxyTest, VerifyQpHistogramStats_Vp9OneSpatialLayer) { @@ -376,7 +369,6 @@ TEST_F(SendStatisticsProxyTest, VerifyQpHistogramStats_Vp9OneSpatialLayer) { statistics_proxy_.reset(new SendStatisticsProxy( &fake_clock_, config, VideoEncoderConfig::ContentType::kRealtimeVideo)); - test::ClearHistograms(); EncodedImage encoded_image; CodecSpecificInfo codec_info; codec_info.codecType = kVideoCodecVP9; @@ -388,8 +380,8 @@ TEST_F(SendStatisticsProxyTest, VerifyQpHistogramStats_Vp9OneSpatialLayer) { statistics_proxy_->OnSendEncodedImage(encoded_image, &codec_info); } statistics_proxy_.reset(); - EXPECT_EQ(1, test::NumHistogramSamples("WebRTC.Video.Encoded.Qp.Vp9")); - EXPECT_EQ(kQpIdx0, test::LastHistogramSample("WebRTC.Video.Encoded.Qp.Vp9")); + EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.Encoded.Qp.Vp9")); + EXPECT_EQ(1, metrics::NumEvents("WebRTC.Video.Encoded.Qp.Vp9", kQpIdx0)); } TEST_F(SendStatisticsProxyTest, NoSubstreams) { @@ -531,26 +523,24 @@ TEST_F(SendStatisticsProxyTest, ResetsRtcpCountersOnContentChange) { // Changing content type causes histograms to be reported. statistics_proxy_->SetContentType(VideoEncoderConfig::ContentType::kScreen); - EXPECT_EQ(1, test::NumHistogramSamples( - "WebRTC.Video.NackPacketsReceivedPerMinute")); - EXPECT_EQ( - 1, test::NumHistogramSamples("WebRTC.Video.FirPacketsReceivedPerMinute")); - EXPECT_EQ( - 1, test::NumHistogramSamples("WebRTC.Video.PliPacketsReceivedPerMinute")); - EXPECT_EQ(1, test::NumHistogramSamples( + EXPECT_EQ(1, + metrics::NumSamples("WebRTC.Video.NackPacketsReceivedPerMinute")); + EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.FirPacketsReceivedPerMinute")); + EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.PliPacketsReceivedPerMinute")); + EXPECT_EQ(1, metrics::NumSamples( "WebRTC.Video.UniqueNackRequestsReceivedInPercent")); const int kRate = 60 * 2; // Packets per minute with two streams. - EXPECT_EQ(1 * kRate, test::LastHistogramSample( - "WebRTC.Video.NackPacketsReceivedPerMinute")); - EXPECT_EQ(2 * kRate, test::LastHistogramSample( - "WebRTC.Video.FirPacketsReceivedPerMinute")); - EXPECT_EQ(3 * kRate, test::LastHistogramSample( - "WebRTC.Video.PliPacketsReceivedPerMinute")); - EXPECT_EQ(4 * 100 / 5, - test::LastHistogramSample( - "WebRTC.Video.UniqueNackRequestsReceivedInPercent")); + EXPECT_EQ(1, metrics::NumEvents("WebRTC.Video.NackPacketsReceivedPerMinute", + 1 * kRate)); + EXPECT_EQ(1, metrics::NumEvents("WebRTC.Video.FirPacketsReceivedPerMinute", + 2 * kRate)); + EXPECT_EQ(1, metrics::NumEvents("WebRTC.Video.PliPacketsReceivedPerMinute", + 3 * kRate)); + EXPECT_EQ( + 1, metrics::NumEvents("WebRTC.Video.UniqueNackRequestsReceivedInPercent", + 4 * 100 / 5)); // New start time but same counter values. proxy->RtcpPacketTypesCounterUpdated(kFirstSsrc, counters); @@ -569,29 +559,29 @@ TEST_F(SendStatisticsProxyTest, ResetsRtcpCountersOnContentChange) { SetUp(); // Reset stats proxy also causes histograms to be reported. - EXPECT_EQ(1, test::NumHistogramSamples( + EXPECT_EQ(1, metrics::NumSamples( "WebRTC.Video.Screenshare.NackPacketsReceivedPerMinute")); - EXPECT_EQ(1, test::NumHistogramSamples( + EXPECT_EQ(1, metrics::NumSamples( "WebRTC.Video.Screenshare.FirPacketsReceivedPerMinute")); - EXPECT_EQ(1, test::NumHistogramSamples( + EXPECT_EQ(1, metrics::NumSamples( "WebRTC.Video.Screenshare.PliPacketsReceivedPerMinute")); EXPECT_EQ( - 1, test::NumHistogramSamples( + 1, metrics::NumSamples( "WebRTC.Video.Screenshare.UniqueNackRequestsReceivedInPercent")); - EXPECT_EQ(1 * kRate, - test::LastHistogramSample( - "WebRTC.Video.Screenshare.NackPacketsReceivedPerMinute")); - EXPECT_EQ(2 * kRate, - test::LastHistogramSample( - "WebRTC.Video.Screenshare.FirPacketsReceivedPerMinute")); - EXPECT_EQ(3 * kRate, - test::LastHistogramSample( - "WebRTC.Video.Screenshare.PliPacketsReceivedPerMinute")); - EXPECT_EQ( - 4 * 100 / 5, - test::LastHistogramSample( - "WebRTC.Video.Screenshare.UniqueNackRequestsReceivedInPercent")); + EXPECT_EQ(1, metrics::NumEvents( + "WebRTC.Video.Screenshare.NackPacketsReceivedPerMinute", + 1 * kRate)); + EXPECT_EQ(1, metrics::NumEvents( + "WebRTC.Video.Screenshare.FirPacketsReceivedPerMinute", + 2 * kRate)); + EXPECT_EQ(1, metrics::NumEvents( + "WebRTC.Video.Screenshare.PliPacketsReceivedPerMinute", + 3 * kRate)); + EXPECT_EQ(1, + metrics::NumEvents( + "WebRTC.Video.Screenshare.UniqueNackRequestsReceivedInPercent", + 4 * 100 / 5)); } TEST_F(SendStatisticsProxyTest, ResetsRtpCountersOnContentChange) { @@ -628,39 +618,46 @@ TEST_F(SendStatisticsProxyTest, ResetsRtpCountersOnContentChange) { // Changing content type causes histograms to be reported. statistics_proxy_->SetContentType(VideoEncoderConfig::ContentType::kScreen); - EXPECT_EQ(1, test::NumHistogramSamples("WebRTC.Video.BitrateSentInKbps")); - EXPECT_EQ(static_cast((counters.transmitted.TotalBytes() * 4 * 8) / - metrics::kMinRunTimeInSeconds / 1000), - test::LastHistogramSample("WebRTC.Video.BitrateSentInKbps")); + EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.BitrateSentInKbps")); + EXPECT_EQ(1, + metrics::NumEvents( + "WebRTC.Video.BitrateSentInKbps", + static_cast((counters.transmitted.TotalBytes() * 4 * 8) / + metrics::kMinRunTimeInSeconds / 1000))); + + EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.MediaBitrateSentInKbps")); + EXPECT_EQ(1, metrics::NumEvents( + "WebRTC.Video.MediaBitrateSentInKbps", + static_cast((counters.MediaPayloadBytes() * 2 * 8) / + metrics::kMinRunTimeInSeconds / 1000))); + + EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.PaddingBitrateSentInKbps")); + EXPECT_EQ(1, + metrics::NumEvents( + "WebRTC.Video.PaddingBitrateSentInKbps", + static_cast((counters.transmitted.padding_bytes * 4 * 8) / + metrics::kMinRunTimeInSeconds / 1000))); EXPECT_EQ(1, - test::NumHistogramSamples("WebRTC.Video.MediaBitrateSentInKbps")); - EXPECT_EQ(static_cast((counters.MediaPayloadBytes() * 2 * 8) / - metrics::kMinRunTimeInSeconds / 1000), - test::LastHistogramSample("WebRTC.Video.MediaBitrateSentInKbps")); - + metrics::NumSamples("WebRTC.Video.RetransmittedBitrateSentInKbps")); EXPECT_EQ(1, - test::NumHistogramSamples("WebRTC.Video.PaddingBitrateSentInKbps")); - EXPECT_EQ(static_cast((counters.transmitted.padding_bytes * 4 * 8) / - metrics::kMinRunTimeInSeconds / 1000), - test::LastHistogramSample("WebRTC.Video.PaddingBitrateSentInKbps")); + metrics::NumEvents( + "WebRTC.Video.RetransmittedBitrateSentInKbps", + static_cast((counters.retransmitted.TotalBytes() * 2 * 8) / + metrics::kMinRunTimeInSeconds / 1000))); - EXPECT_EQ(1, test::NumHistogramSamples( - "WebRTC.Video.RetransmittedBitrateSentInKbps")); + EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.RtxBitrateSentInKbps")); EXPECT_EQ( - static_cast((counters.retransmitted.TotalBytes() * 2 * 8) / - metrics::kMinRunTimeInSeconds / 1000), - test::LastHistogramSample("WebRTC.Video.RetransmittedBitrateSentInKbps")); + 1, metrics::NumEvents( + "WebRTC.Video.RtxBitrateSentInKbps", + static_cast((rtx_counters.transmitted.TotalBytes() * 2 * 8) / + metrics::kMinRunTimeInSeconds / 1000))); - EXPECT_EQ(1, test::NumHistogramSamples("WebRTC.Video.RtxBitrateSentInKbps")); - EXPECT_EQ(static_cast((rtx_counters.transmitted.TotalBytes() * 2 * 8) / - metrics::kMinRunTimeInSeconds / 1000), - test::LastHistogramSample("WebRTC.Video.RtxBitrateSentInKbps")); - - EXPECT_EQ(1, test::NumHistogramSamples("WebRTC.Video.FecBitrateSentInKbps")); - EXPECT_EQ(static_cast((rtx_counters.fec.TotalBytes() * 2 * 8) / - metrics::kMinRunTimeInSeconds / 1000), - test::LastHistogramSample("WebRTC.Video.FecBitrateSentInKbps")); + EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.FecBitrateSentInKbps")); + EXPECT_EQ(1, metrics::NumEvents( + "WebRTC.Video.FecBitrateSentInKbps", + static_cast((rtx_counters.fec.TotalBytes() * 2 * 8) / + metrics::kMinRunTimeInSeconds / 1000))); // New start time but same counter values. proxy->DataCountersUpdated(counters, kFirstSsrc); @@ -683,47 +680,51 @@ TEST_F(SendStatisticsProxyTest, ResetsRtpCountersOnContentChange) { SetUp(); // Reset stats proxy also causes histograms to be reported. - EXPECT_EQ(1, test::NumHistogramSamples( - "WebRTC.Video.Screenshare.BitrateSentInKbps")); - EXPECT_EQ( - static_cast((counters.transmitted.TotalBytes() * 4 * 8) / - metrics::kMinRunTimeInSeconds / 1000), - test::LastHistogramSample("WebRTC.Video.Screenshare.BitrateSentInKbps")); + EXPECT_EQ(1, + metrics::NumSamples("WebRTC.Video.Screenshare.BitrateSentInKbps")); + EXPECT_EQ(1, + metrics::NumEvents( + "WebRTC.Video.Screenshare.BitrateSentInKbps", + static_cast((counters.transmitted.TotalBytes() * 4 * 8) / + metrics::kMinRunTimeInSeconds / 1000))); - EXPECT_EQ(1, test::NumHistogramSamples( + EXPECT_EQ(1, metrics::NumSamples( "WebRTC.Video.Screenshare.MediaBitrateSentInKbps")); - EXPECT_EQ(static_cast((counters.MediaPayloadBytes() * 2 * 8) / - metrics::kMinRunTimeInSeconds / 1000), - test::LastHistogramSample( - "WebRTC.Video.Screenshare.MediaBitrateSentInKbps")); + EXPECT_EQ(1, metrics::NumEvents( + "WebRTC.Video.Screenshare.MediaBitrateSentInKbps", + static_cast((counters.MediaPayloadBytes() * 2 * 8) / + metrics::kMinRunTimeInSeconds / 1000))); - EXPECT_EQ(1, test::NumHistogramSamples( + EXPECT_EQ(1, metrics::NumSamples( "WebRTC.Video.Screenshare.PaddingBitrateSentInKbps")); - EXPECT_EQ(static_cast((counters.transmitted.padding_bytes * 4 * 8) / - metrics::kMinRunTimeInSeconds / 1000), - test::LastHistogramSample( - "WebRTC.Video.Screenshare.PaddingBitrateSentInKbps")); + EXPECT_EQ(1, + metrics::NumEvents( + "WebRTC.Video.Screenshare.PaddingBitrateSentInKbps", + static_cast((counters.transmitted.padding_bytes * 4 * 8) / + metrics::kMinRunTimeInSeconds / 1000))); - EXPECT_EQ(1, test::NumHistogramSamples( + EXPECT_EQ(1, metrics::NumSamples( "WebRTC.Video.Screenshare.RetransmittedBitrateSentInKbps")); - EXPECT_EQ(static_cast((counters.retransmitted.TotalBytes() * 2 * 8) / - metrics::kMinRunTimeInSeconds / 1000), - test::LastHistogramSample( - "WebRTC.Video.Screenshare.RetransmittedBitrateSentInKbps")); + EXPECT_EQ(1, + metrics::NumEvents( + "WebRTC.Video.Screenshare.RetransmittedBitrateSentInKbps", + static_cast((counters.retransmitted.TotalBytes() * 2 * 8) / + metrics::kMinRunTimeInSeconds / 1000))); - EXPECT_EQ(1, test::NumHistogramSamples( - "WebRTC.Video.Screenshare.RtxBitrateSentInKbps")); - EXPECT_EQ(static_cast((rtx_counters.transmitted.TotalBytes() * 2 * 8) / - metrics::kMinRunTimeInSeconds / 1000), - test::LastHistogramSample( - "WebRTC.Video.Screenshare.RtxBitrateSentInKbps")); + EXPECT_EQ( + 1, metrics::NumSamples("WebRTC.Video.Screenshare.RtxBitrateSentInKbps")); + EXPECT_EQ( + 1, metrics::NumEvents( + "WebRTC.Video.Screenshare.RtxBitrateSentInKbps", + static_cast((rtx_counters.transmitted.TotalBytes() * 2 * 8) / + metrics::kMinRunTimeInSeconds / 1000))); - EXPECT_EQ(1, test::NumHistogramSamples( - "WebRTC.Video.Screenshare.FecBitrateSentInKbps")); - EXPECT_EQ(static_cast((rtx_counters.fec.TotalBytes() * 2 * 8) / - metrics::kMinRunTimeInSeconds / 1000), - test::LastHistogramSample( - "WebRTC.Video.Screenshare.FecBitrateSentInKbps")); + EXPECT_EQ( + 1, metrics::NumSamples("WebRTC.Video.Screenshare.FecBitrateSentInKbps")); + EXPECT_EQ(1, metrics::NumEvents( + "WebRTC.Video.Screenshare.FecBitrateSentInKbps", + static_cast((rtx_counters.fec.TotalBytes() * 2 * 8) / + metrics::kMinRunTimeInSeconds / 1000))); } } // namespace webrtc