Skip to content

GitLab

T
tangled
Commit 01d208fe authored by Brian Sheedy's avatar Brian Sheedy Committed by Commit Bot
Browse files
Options

Revert "Switch WebRTC browser perf tests to histograms" 

This reverts commit 8e751655.

Reason for revert: There are apparently more conversions required in third_party/webrtc

Original change's description:
> Switch WebRTC browser perf tests to histograms
> 
> Switches uses of PrintResult in the WebRTC browser perf tests to
> PerfResultReporter and whitelists browser_tests for conversion to
> histograms before uploading to the perf dashboard.
> 
> Bug: 923564
> Change-Id: I7ff090bcdeaf3906491b85993456f07313cd4a52
> Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1856825
> Reviewed-by: Patrik Höglund <phoglund@chromium.org>
> Reviewed-by: Yuri Wiitala <miu@chromium.org>
> Commit-Queue: Brian Sheedy <bsheedy@chromium.org>
> Cr-Commit-Position: refs/heads/master@{#706699}

TBR=miu@chromium.org,phoglund@chromium.org,bsheedy@chromium.org

Change-Id: I80e804f4b38699adaa6cce33b48a57769a2a6db5
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Bug: 923564
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1866627Reviewed-by: default avatarBrian Sheedy <bsheedy@chromium.org>
Commit-Queue: Brian Sheedy <bsheedy@chromium.org>
Cr-Commit-Position: refs/heads/master@{#706985}
parent e5b3d989
Show whitespace changes
Inline Side-by-side
Showing with 170 additions and 288 deletions
chrome/browser/media/webrtc/webrtc_browsertest_perf.cc
View file @ 01d208fe
......@@ -9,106 +9,7 @@
#include "base/strings/stringprintf.h"
#include "base/values.h"
#include "chrome/test/base/in_process_browser_test.h"
#include "testing/perf/perf_result_reporter.h"
namespace {
constexpr char kMetricPrefixAudioReceive[] = "WebRtcAudioReceive.";
constexpr char kMetricPrefixAudioSend[] = "WebRtcAudioSend.";
constexpr char kMetricPrefixVideoSend[] = "WebRtcVideoSend.";
constexpr char kMetricPrefixVideoRecieve[] = "WebRtcVideoReceive.";
constexpr char kMetricPrefixBwe[] = "WebRtcBwe.";
constexpr char kMetricPacketsLostFrames[] = "packets_lost";
constexpr char kMetricGoogJitterRecvMs[] = "goog_jitter_recv";
constexpr char kMetricGoogExpandRatePercent[] = "goog_expand_rate";
constexpr char kMetricGoogSpeechExpandRatePercent[] = "goog_speech_expand_rate";
constexpr char kMetricGoogSecondaryDecodeRatePercent[] =
"goog_secondary_decode_rate";
constexpr char kMetricGoogRttMs[] = "goog_rtt";
constexpr char kMetricPacketsPerSecondPackets[] = "packets_per_second";
constexpr char kMetricGoogFpsSentFps[] = "goog_frame_rate_sent";
constexpr char kMetricGoogFpsInputFps[] = "goog_frame_rate_input";
constexpr char kMetricGoogFirsReceivedUnitless[] = "goog_firs_recv";
constexpr char kMetricGoogNacksReceivedUnitless[] = "goog_nacks_recv";
constexpr char kMetricGoogFrameWidthCount[] = "goog_frame_width";
constexpr char kMetricGoogFrameHeightCount[] = "goog_frame_height";
constexpr char kMetricGoogAvgEncodeMs[] = "goog_avg_encode";
constexpr char kMetricGoogEncodeCpuUsagePercent[] = "goog_encode_cpu_usage";
constexpr char kMetricGoogFpsRecvFps[] = "goog_frame_rate_recv";
constexpr char kMetricGoogFpsOutputFps[] = "goog_frame_rate_output";
constexpr char kMetricGoogActualDelayMs[] = "goog_actual_delay";
constexpr char kMetricGoogTargetDelayMs[] = "goog_target_delay";
constexpr char kMetricGoogDecodeTimeMs[] = "goog_decode_time";
constexpr char kMetricGoogMaxDecodeTimeMs[] = "goog_max_decode_time";
constexpr char kMetricGoogJitterBufferMs[] = "goog_jitter_buffer";
constexpr char kMetricGoogRenderDelayMs[] = "goog_render_delay";
constexpr char kMetricAvailableSendBandwidthBitsPerS[] = "available_send_bw";
constexpr char kMetricAvailableRecvBandwidthBitsPerS[] = "available_recv_bw";
constexpr char kMetricTargetEncodeBitrateBitsPerS[] = "target_encode_bitrate";
constexpr char kMetricActualEncodeBitrateBitsPerS[] = "actual_encode_bitrate";
constexpr char kMetricTransmitBitrateBitsPerS[] = "transmit_bitrate";
perf_test::PerfResultReporter SetUpAudioReceiveReporter(
const std::string& story) {
perf_test::PerfResultReporter reporter(kMetricPrefixAudioReceive, story);
reporter.RegisterFyiMetric(kMetricPacketsLostFrames, "frames");
reporter.RegisterFyiMetric(kMetricGoogJitterRecvMs, "ms");
reporter.RegisterFyiMetric(kMetricGoogExpandRatePercent, "%");
reporter.RegisterFyiMetric(kMetricGoogSpeechExpandRatePercent, "%");
reporter.RegisterFyiMetric(kMetricGoogSecondaryDecodeRatePercent, "%");
return reporter;
}
perf_test::PerfResultReporter SetUpAudioSendReporter(const std::string& story) {
perf_test::PerfResultReporter reporter(kMetricPrefixAudioSend, story);
reporter.RegisterFyiMetric(kMetricGoogJitterRecvMs, "ms");
reporter.RegisterFyiMetric(kMetricGoogRttMs, "ms");
reporter.RegisterFyiMetric(kMetricPacketsPerSecondPackets, "packets");
return reporter;
}
perf_test::PerfResultReporter SetUpVideoSendReporter(const std::string& story) {
perf_test::PerfResultReporter reporter(kMetricPrefixVideoSend, story);
reporter.RegisterFyiMetric(kMetricGoogFpsSentFps, "fps");
reporter.RegisterFyiMetric(kMetricGoogFpsInputFps, "fps");
reporter.RegisterFyiMetric(kMetricGoogFirsReceivedUnitless, "unitless");
reporter.RegisterFyiMetric(kMetricGoogNacksReceivedUnitless, "unitless");
reporter.RegisterFyiMetric(kMetricGoogFrameWidthCount, "count");
reporter.RegisterFyiMetric(kMetricGoogFrameHeightCount, "count");
reporter.RegisterFyiMetric(kMetricGoogAvgEncodeMs, "ms");
reporter.RegisterFyiMetric(kMetricGoogRttMs, "ms");
reporter.RegisterFyiMetric(kMetricGoogEncodeCpuUsagePercent, "%");
return reporter;
}
perf_test::PerfResultReporter SetUpVideoReceiveReporter(
const std::string& story) {
perf_test::PerfResultReporter reporter(kMetricPrefixVideoRecieve, story);
reporter.RegisterFyiMetric(kMetricGoogFpsRecvFps, "fps");
reporter.RegisterFyiMetric(kMetricGoogFpsOutputFps, "fps");
reporter.RegisterFyiMetric(kMetricPacketsLostFrames, "frames");
reporter.RegisterFyiMetric(kMetricGoogFrameWidthCount, "count");
reporter.RegisterFyiMetric(kMetricGoogFrameHeightCount, "count");
reporter.RegisterFyiMetric(kMetricGoogActualDelayMs, "ms");
reporter.RegisterFyiMetric(kMetricGoogTargetDelayMs, "ms");
reporter.RegisterFyiMetric(kMetricGoogDecodeTimeMs, "ms");
reporter.RegisterFyiMetric(kMetricGoogMaxDecodeTimeMs, "ms");
reporter.RegisterFyiMetric(kMetricGoogJitterBufferMs, "ms");
reporter.RegisterFyiMetric(kMetricGoogRenderDelayMs, "ms");
return reporter;
}
perf_test::PerfResultReporter SetUpBweReporter(const std::string& story) {
perf_test::PerfResultReporter reporter(kMetricPrefixBwe, story);
reporter.RegisterFyiMetric(kMetricAvailableSendBandwidthBitsPerS, "bits/s");
reporter.RegisterFyiMetric(kMetricAvailableRecvBandwidthBitsPerS, "bits/s");
reporter.RegisterFyiMetric(kMetricTargetEncodeBitrateBitsPerS, "bits/s");
reporter.RegisterFyiMetric(kMetricActualEncodeBitrateBitsPerS, "bits/s");
reporter.RegisterFyiMetric(kMetricTransmitBitrateBitsPerS, "bits/s");
return reporter;
}
} // namespace
#include "testing/perf/perf_test.h"
static std::string Statistic(const std::string& statistic,
const std::string& bucket) {
......@@ -122,53 +23,59 @@ static std::string Statistic(const std::string& statistic,
}
static void MaybePrintResultsForAudioReceive(
const std::string& ssrc,
const base::DictionaryValue& pc_dict,
const std::string& story) {
const std::string& ssrc, const base::DictionaryValue& pc_dict,
const std::string& modifier) {
std::string value;
if (!pc_dict.GetString(Statistic("audioOutputLevel", ssrc), &value)) {
// Not an audio receive stream.
return;
}
auto reporter = SetUpAudioReceiveReporter(story);
EXPECT_TRUE(pc_dict.GetString(Statistic("packetsLost", ssrc), &value));
reporter.AddResult(kMetricPacketsLostFrames, value);
perf_test::PrintResult(
"audio_misc", modifier, "packets_lost", value, "frames", false);
EXPECT_TRUE(pc_dict.GetString(Statistic("googJitterReceived", ssrc), &value));
reporter.AddResult(kMetricGoogJitterRecvMs, value);
perf_test::PrintResult(
"audio_rx", modifier, "goog_jitter_recv", value, "ms", false);
EXPECT_TRUE(pc_dict.GetString(Statistic("googExpandRate", ssrc), &value));
reporter.AddResult(kMetricGoogExpandRatePercent, value);
perf_test::PrintResult(
"audio_rates", modifier, "goog_expand_rate", value, "%", false);
EXPECT_TRUE(
pc_dict.GetString(Statistic("googSpeechExpandRate", ssrc), &value));
reporter.AddResult(kMetricGoogSpeechExpandRatePercent, value);
perf_test::PrintResult(
"audio_rates", modifier, "goog_speech_expand_rate", value, "%", false);
EXPECT_TRUE(
pc_dict.GetString(Statistic("googSecondaryDecodedRate", ssrc), &value));
reporter.AddResult(kMetricGoogSecondaryDecodeRatePercent, value);
perf_test::PrintResult(
"audio_rates", modifier, "goog_secondary_decoded_rate", value, "%",
false);
}
static void MaybePrintResultsForAudioSend(const std::string& ssrc,
const base::DictionaryValue& pc_dict,
const std::string& story) {
static void MaybePrintResultsForAudioSend(
const std::string& ssrc, const base::DictionaryValue& pc_dict,
const std::string& modifier) {
std::string value;
if (!pc_dict.GetString(Statistic("audioInputLevel", ssrc), &value)) {
// Not an audio send stream.
return;
}
auto reporter = SetUpAudioSendReporter(story);
EXPECT_TRUE(pc_dict.GetString(Statistic("googJitterReceived", ssrc), &value));
reporter.AddResult(kMetricGoogJitterRecvMs, value);
perf_test::PrintResult(
"audio_tx", modifier, "goog_jitter_recv", value, "ms", false);
EXPECT_TRUE(pc_dict.GetString(Statistic("googRtt", ssrc), &value));
reporter.AddResult(kMetricGoogRttMs, value);
perf_test::PrintResult(
"audio_tx", modifier, "goog_rtt", value, "ms", false);
EXPECT_TRUE(
pc_dict.GetString(Statistic("packetsSentPerSecond", ssrc), &value));
reporter.AddResult(kMetricPacketsPerSecondPackets, value);
perf_test::PrintResult("audio_tx", modifier, "packets_sent_per_second", value,
"packets", false);
}
static void MaybePrintResultsForVideoSend(const std::string& ssrc,
const base::DictionaryValue& pc_dict,
const std::string& story) {
static void MaybePrintResultsForVideoSend(
const std::string& ssrc, const base::DictionaryValue& pc_dict,
const std::string& modifier) {
std::string value;
if (!pc_dict.GetString(Statistic("googFrameRateSent", ssrc), &value)) {
// Not a video send stream.
......@@ -178,70 +85,86 @@ static void MaybePrintResultsForVideoSend(const std::string& ssrc,
// Graph these by unit: the dashboard expects all stats in one graph to have
// the same unit (e.g. ms, fps, etc). Most graphs, like video_fps, will also
// be populated by the counterparts on the video receiving side.
auto reporter = SetUpVideoSendReporter(story);
reporter.AddResult(kMetricGoogFpsSentFps, value);
perf_test::PrintResult(
"video_fps", modifier, "goog_frame_rate_sent", value, "fps", false);
EXPECT_TRUE(pc_dict.GetString(Statistic("googFrameRateInput", ssrc), &value));
reporter.AddResult(kMetricGoogFpsInputFps, value);
perf_test::PrintResult(
"video_fps", modifier, "goog_frame_rate_input", value, "fps", false);
EXPECT_TRUE(pc_dict.GetString(Statistic("googFirsReceived", ssrc), &value));
reporter.AddResult(kMetricGoogFirsReceivedUnitless, value);
perf_test::PrintResult(
"video_misc", modifier, "goog_firs_recv", value, "", false);
EXPECT_TRUE(pc_dict.GetString(Statistic("googNacksReceived", ssrc), &value));
reporter.AddResult(kMetricGoogNacksReceivedUnitless, value);
perf_test::PrintResult(
"video_misc", modifier, "goog_nacks_recv", value, "", false);
EXPECT_TRUE(pc_dict.GetString(Statistic("googFrameWidthSent", ssrc), &value));
reporter.AddResult(kMetricGoogFrameWidthCount, value);
perf_test::PrintResult("video_resolution", modifier, "goog_frame_width_sent",
value, "pixels", false);
EXPECT_TRUE(
pc_dict.GetString(Statistic("googFrameHeightSent", ssrc), &value));
reporter.AddResult(kMetricGoogFrameHeightCount, value);
perf_test::PrintResult("video_resolution", modifier, "goog_frame_height_sent",
value, "pixels", false);
EXPECT_TRUE(pc_dict.GetString(Statistic("googAvgEncodeMs", ssrc), &value));
reporter.AddResult(kMetricGoogAvgEncodeMs, value);
perf_test::PrintResult(
"video_tx", modifier, "goog_avg_encode_ms", value, "ms", false);
EXPECT_TRUE(pc_dict.GetString(Statistic("googRtt", ssrc), &value));
reporter.AddResult(kMetricGoogRttMs, value);
perf_test::PrintResult("video_tx", modifier, "goog_rtt", value, "ms", false);
EXPECT_TRUE(pc_dict.GetString(
Statistic("googEncodeUsagePercent", ssrc), &value));
reporter.AddResult(kMetricGoogEncodeCpuUsagePercent, value);
perf_test::PrintResult("video_cpu_usage", modifier,
"goog_encode_usage_percent", value, "%", false);
}
static void MaybePrintResultsForVideoReceive(
const std::string& ssrc,
const base::DictionaryValue& pc_dict,
const std::string& story) {
const std::string& ssrc, const base::DictionaryValue& pc_dict,
const std::string& modifier) {
std::string value;
if (!pc_dict.GetString(Statistic("googFrameRateReceived", ssrc), &value)) {
// Not a video receive stream.
return;
}
auto reporter = SetUpVideoReceiveReporter(story);
reporter.AddResult(kMetricGoogFpsRecvFps, value);
perf_test::PrintResult(
"video_fps", modifier, "goog_frame_rate_recv", value, "fps", false);
EXPECT_TRUE(
pc_dict.GetString(Statistic("googFrameRateOutput", ssrc), &value));
reporter.AddResult(kMetricGoogFpsOutputFps, value);
perf_test::PrintResult(
"video_fps", modifier, "goog_frame_rate_output", value, "fps", false);
EXPECT_TRUE(pc_dict.GetString(Statistic("packetsLost", ssrc), &value));
reporter.AddResult(kMetricPacketsLostFrames, value);
perf_test::PrintResult("video_misc", modifier, "packets_lost", value,
"frames", false);
EXPECT_TRUE(
pc_dict.GetString(Statistic("googFrameWidthReceived", ssrc), &value));
reporter.AddResult(kMetricGoogFrameWidthCount, value);
perf_test::PrintResult("video_resolution", modifier, "goog_frame_width_recv",
value, "pixels", false);
EXPECT_TRUE(
pc_dict.GetString(Statistic("googFrameHeightReceived", ssrc), &value));
reporter.AddResult(kMetricGoogFrameHeightCount, value);
perf_test::PrintResult("video_resolution", modifier, "goog_frame_height_recv",
value, "pixels", false);
EXPECT_TRUE(pc_dict.GetString(Statistic("googCurrentDelayMs", ssrc), &value));
reporter.AddResult(kMetricGoogActualDelayMs, value);
perf_test::PrintResult(
"video_rx", modifier, "goog_current_delay_ms", value, "ms", false);
EXPECT_TRUE(pc_dict.GetString(Statistic("googTargetDelayMs", ssrc), &value));
reporter.AddResult(kMetricGoogTargetDelayMs, value);
perf_test::PrintResult(
"video_rx", modifier, "goog_target_delay_ms", value, "ms", false);
EXPECT_TRUE(pc_dict.GetString(Statistic("googDecodeMs", ssrc), &value));
reporter.AddResult(kMetricGoogDecodeTimeMs, value);
perf_test::PrintResult("video_rx", modifier, "goog_decode_ms", value, "ms",
false);
EXPECT_TRUE(pc_dict.GetString(Statistic("googMaxDecodeMs", ssrc), &value));
reporter.AddResult(kMetricGoogMaxDecodeTimeMs, value);
perf_test::PrintResult(
"video_rx", modifier, "goog_max_decode_ms", value, "ms", false);
EXPECT_TRUE(pc_dict.GetString(Statistic("googJitterBufferMs", ssrc), &value));
reporter.AddResult(kMetricGoogJitterBufferMs, value);
perf_test::PrintResult(
"video_rx", modifier, "goog_jitter_buffer_ms", value, "ms", false);
EXPECT_TRUE(pc_dict.GetString(Statistic("googRenderDelayMs", ssrc), &value));
reporter.AddResult(kMetricGoogRenderDelayMs, value);
perf_test::PrintResult(
"video_rx", modifier, "goog_render_delay_ms", value, "ms", false);
}
static std::string ExtractSsrcIdentifier(const std::string& key) {
......@@ -272,26 +195,30 @@ namespace test {
void PrintBweForVideoMetrics(const base::DictionaryValue& pc_dict,
const std::string& modifier,
const std::string& video_codec) {
std::string story = video_codec.empty() ? "baseline_story" : video_codec;
story += modifier;
std::string video_modifier =
video_codec.empty() ? modifier : modifier + "_" + video_codec;
const std::string kBweStatsKey = "bweforvideo";
std::string value;
auto reporter = SetUpBweReporter(story);
ASSERT_TRUE(pc_dict.GetString(
Statistic("googAvailableSendBandwidth", kBweStatsKey), &value));
reporter.AddResult(kMetricAvailableSendBandwidthBitsPerS, value);
perf_test::PrintResult("bwe_stats", video_modifier, "available_send_bw",
value, "bit/s", false);
ASSERT_TRUE(pc_dict.GetString(
Statistic("googAvailableReceiveBandwidth", kBweStatsKey), &value));
reporter.AddResult(kMetricAvailableRecvBandwidthBitsPerS, value);
perf_test::PrintResult("bwe_stats", video_modifier, "available_recv_bw",
value, "bit/s", false);
ASSERT_TRUE(pc_dict.GetString(
Statistic("googTargetEncBitrate", kBweStatsKey), &value));
reporter.AddResult(kMetricTargetEncodeBitrateBitsPerS, value);
perf_test::PrintResult("bwe_stats", video_modifier, "target_enc_bitrate",
value, "bit/s", false);
ASSERT_TRUE(pc_dict.GetString(
Statistic("googActualEncBitrate", kBweStatsKey), &value));
reporter.AddResult(kMetricActualEncodeBitrateBitsPerS, value);
perf_test::PrintResult("bwe_stats", video_modifier, "actual_enc_bitrate",
value, "bit/s", false);
ASSERT_TRUE(pc_dict.GetString(
Statistic("googTransmitBitrate", kBweStatsKey), &value));
reporter.AddResult(kMetricTransmitBitrateBitsPerS, value);
perf_test::PrintResult("bwe_stats", video_modifier, "transmit_bitrate", value,
"bit/s", false);
}
void PrintMetricsForAllStreams(const base::DictionaryValue& pc_dict,
......@@ -304,8 +231,8 @@ void PrintMetricsForAllStreams(const base::DictionaryValue& pc_dict,
void PrintMetricsForSendStreams(const base::DictionaryValue& pc_dict,
const std::string& modifier,
const std::string& video_codec) {
std::string story = video_codec.empty() ? "baseline_story" : video_codec;
story += modifier;
std::string video_modifier =
video_codec.empty() ? modifier : modifier + "_" + video_codec;
const base::DictionaryValue* stats_dict;
ASSERT_TRUE(pc_dict.GetDictionary("stats", &stats_dict));
std::set<std::string> ssrc_identifiers = FindAllSsrcIdentifiers(*stats_dict);
......@@ -313,16 +240,16 @@ void PrintMetricsForSendStreams(const base::DictionaryValue& pc_dict,
auto ssrc_iterator = ssrc_identifiers.begin();
for (; ssrc_iterator != ssrc_identifiers.end(); ++ssrc_iterator) {
const std::string& ssrc = *ssrc_iterator;
MaybePrintResultsForAudioSend(ssrc, pc_dict, story);
MaybePrintResultsForVideoSend(ssrc, pc_dict, story);
MaybePrintResultsForAudioSend(ssrc, pc_dict, modifier);
MaybePrintResultsForVideoSend(ssrc, pc_dict, video_modifier);
}
}
void PrintMetricsForRecvStreams(const base::DictionaryValue& pc_dict,
const std::string& modifier,
const std::string& video_codec) {
std::string story = video_codec.empty() ? "baseline_story" : video_codec;
story += modifier;
std::string video_modifier =
video_codec.empty() ? modifier : modifier + "_" + video_codec;
const base::DictionaryValue* stats_dict;
ASSERT_TRUE(pc_dict.GetDictionary("stats", &stats_dict));
std::set<std::string> ssrc_identifiers = FindAllSsrcIdentifiers(*stats_dict);
......@@ -330,8 +257,8 @@ void PrintMetricsForRecvStreams(const base::DictionaryValue& pc_dict,
auto ssrc_iterator = ssrc_identifiers.begin();
for (; ssrc_iterator != ssrc_identifiers.end(); ++ssrc_iterator) {
const std::string& ssrc = *ssrc_iterator;
MaybePrintResultsForAudioReceive(ssrc, pc_dict, story);
MaybePrintResultsForVideoReceive(ssrc, pc_dict, story);
MaybePrintResultsForAudioReceive(ssrc, pc_dict, modifier);
MaybePrintResultsForVideoReceive(ssrc, pc_dict, video_modifier);
}
}
......
chrome/browser/media/webrtc/webrtc_stats_perf_browsertest.cc
View file @ 01d208fe
......@@ -14,7 +14,7 @@
#include "chrome/browser/media/webrtc/webrtc_browsertest_common.h"
#include "content/public/common/content_switches.h"
#include "media/base/media_switches.h"
#include "testing/perf/perf_result_reporter.h"
#include "testing/perf/perf_test.h"
#include "third_party/blink/public/common/features.h"
namespace content {
......@@ -26,35 +26,6 @@ const char kMainWebrtcTestHtmlPage[] = "/webrtc/webrtc_jsep01_test.html";
const char kInboundRtp[] = "inbound-rtp";
const char kOutboundRtp[] = "outbound-rtp";
constexpr int kBitsPerByte = 8;
constexpr char kMetricPrefixAudioStats[] = "WebRtcAudioStats.";
constexpr char kMetricPrefixVideoStats[] = "WebRtcVideoStats.";
constexpr char kMetricPrefixGetStats[] = "WebRtcGetStats.";
constexpr char kMetricSendRateBitsPerS[] = "send_rate";
constexpr char kMetricReceiveRateBitsPerS[] = "receive_rate";
constexpr char kMetricInvocationTimeMs[] = "invocation_time";
perf_test::PerfResultReporter SetUpAudioReporter(const std::string& story) {
perf_test::PerfResultReporter reporter(kMetricPrefixAudioStats, story);
reporter.RegisterFyiMetric(kMetricSendRateBitsPerS, "bits/s");
reporter.RegisterFyiMetric(kMetricReceiveRateBitsPerS, "bits/s");
return reporter;
}
perf_test::PerfResultReporter SetUpVideoReporter(const std::string& story) {
perf_test::PerfResultReporter reporter(kMetricPrefixVideoStats, story);
reporter.RegisterFyiMetric(kMetricSendRateBitsPerS, "bits/s");
reporter.RegisterFyiMetric(kMetricReceiveRateBitsPerS, "bits/s");
return reporter;
}
perf_test::PerfResultReporter SetUpGetStatsReporter(const std::string& story) {
perf_test::PerfResultReporter reporter(kMetricPrefixGetStats, story);
reporter.RegisterFyiMetric(kMetricInvocationTimeMs, "ms");
return reporter;
}
enum class GetStatsVariation {
PROMISE_BASED,
CALLBACK_BASED
......@@ -229,11 +200,13 @@ class WebRtcStatsPerfBrowserTest : public WebRtcTestBase {
(audio_bytes_received_after - audio_bytes_received_before) /
measure_duration_seconds;
auto reporter = SetUpAudioReporter(audio_codec);
reporter.AddResult(kMetricSendRateBitsPerS,
audio_send_rate * kBitsPerByte);
reporter.AddResult(kMetricReceiveRateBitsPerS,
audio_receive_rate * kBitsPerByte);
std::string audio_codec_modifier = "_" + audio_codec;
perf_test::PrintResult(
"audio", audio_codec_modifier, "send_rate", audio_send_rate,
"bytes/second", false);
perf_test::PrintResult(
"audio", audio_codec_modifier, "receive_rate", audio_receive_rate,
"bytes/second", false);
}
if (video_codec != kUseDefaultVideoCodec) {
double video_bytes_sent_after = GetVideoBytesSent(report.get());
......@@ -246,14 +219,15 @@ class WebRtcStatsPerfBrowserTest : public WebRtcTestBase {
(video_bytes_received_after - video_bytes_received_before) /
measure_duration_seconds;
std::string story =
(video_codec_print_modifier.empty() ? video_codec
std::string video_codec_modifier =
"_" + (video_codec_print_modifier.empty()
? video_codec
: video_codec_print_modifier);
auto reporter = SetUpVideoReporter(story);
reporter.AddResult(kMetricSendRateBitsPerS,
video_send_rate * kBitsPerByte);
reporter.AddResult(kMetricReceiveRateBitsPerS,
video_receive_rate * kBitsPerByte);
perf_test::PrintResult("video", video_codec_modifier, "send_rate",
video_send_rate, "bytes/second", false);
perf_test::PrintResult(
"video", video_codec_modifier, "receive_rate", video_receive_rate,
"bytes/second", false);
}
EndCall();
......@@ -278,9 +252,14 @@ class WebRtcStatsPerfBrowserTest : public WebRtcTestBase {
MeasureGetStatsCallbackPerformance(right_tab_)) / 2.0;
break;
}
auto reporter = SetUpGetStatsReporter(
variation == GetStatsVariation::PROMISE_BASED ? "promise" : "callback");
reporter.AddResult(kMetricInvocationTimeMs, invocation_time);
perf_test::PrintResult(
"getStats",
(variation == GetStatsVariation::PROMISE_BASED) ?
"_promise" : "_callback",
"invocation_time",
invocation_time,
"milliseconds",
false);
EndCall();
}
......
chrome/browser/media/webrtc/webrtc_video_display_perf_browsertest.cc
View file @ 01d208fe
......@@ -21,7 +21,7 @@
#include "content/public/test/browser_test_utils.h"
#include "media/base/media_switches.h"
#include "net/test/embedded_test_server/embedded_test_server.h"
#include "testing/perf/perf_result_reporter.h"
#include "testing/perf/perf_test.h"
#include "third_party/blink/public/common/features.h"
#include "ui/gl/gl_switches.h"
......@@ -49,42 +49,10 @@ static const char kVsyncEventName[] = "Display::DrawAndSwap";
static const char kVideoFrameSubmitterEventName[] = "VideoFrameSubmitter";
static const char kEventMatchKey[] = "Timestamp";
static const char kTestResultString[] = "TestVideoDisplayPerf";
static const char kMainWebrtcTestHtmlPage[] =
"/webrtc/webrtc_video_display_perf_test.html";
constexpr char kMetricPrefixVideoDisplayPerf[] = "WebRtcVideoDisplayPerf.";
constexpr char kMetricSkippedFramesPercent[] = "skipped_frames";
constexpr char kMetricPassingToRenderAlgoLatencyUs[] =
"passing_to_render_algorithm_latency";
constexpr char kMetricRenderAlgoLatencyUs[] = "render_algorithm_latency";
constexpr char kMetricCompositorPickingFrameLatencyUs[] =
"compositor_picking_frame_latency";
constexpr char kMetricCompositorResourcePreparationLatencyUs[] =
"compositor_resource_preparation_latency";
constexpr char kMetricVsyncLatencyUs[] = "vsync_latency";
constexpr char kMetricTotalControlledLatencyUs[] = "total_controlled_latency";
constexpr char kMetricTotalLatencyUs[] = "total_latency";
constexpr char kMetricPostDecodeToRasterLatencyUs[] =
"post_decode_to_raster_latency";
constexpr char kMetricWebRtcDecodeLatencyUs[] = "webrtc_decode_latency";
perf_test::PerfResultReporter SetUpReporter(const std::string& story) {
perf_test::PerfResultReporter reporter(kMetricPrefixVideoDisplayPerf, story);
reporter.RegisterImportantMetric(kMetricSkippedFramesPercent, "percent");
reporter.RegisterImportantMetric(kMetricPassingToRenderAlgoLatencyUs, "us");
reporter.RegisterImportantMetric(kMetricRenderAlgoLatencyUs, "us");
reporter.RegisterImportantMetric(kMetricCompositorPickingFrameLatencyUs,
"us");
reporter.RegisterImportantMetric(
kMetricCompositorResourcePreparationLatencyUs, "us");
reporter.RegisterImportantMetric(kMetricVsyncLatencyUs, "us");
reporter.RegisterImportantMetric(kMetricTotalControlledLatencyUs, "us");
reporter.RegisterImportantMetric(kMetricTotalLatencyUs, "us");
reporter.RegisterImportantMetric(kMetricPostDecodeToRasterLatencyUs, "us");
reporter.RegisterImportantMetric(kMetricWebRtcDecodeLatencyUs, "us");
return reporter;
}
struct VideoDisplayPerfTestConfig {
int width;
int height;
......@@ -92,13 +60,36 @@ struct VideoDisplayPerfTestConfig {
bool disable_render_smoothness_algorithm;
};
std::string VectorToString(const std::vector<double>& values) {
std::string ret = "";
for (double val : values) {
ret += base::StringPrintf("%.0lf,", val);
void CalculateMeanAndMax(const std::vector<double>& inputs,
double* mean,
double* std_dev,
double* max) {
double sum = 0.0;
double sqr_sum = 0.0;
double max_so_far = 0.0;
size_t count = inputs.size();
for (const auto& input : inputs) {
sum += input;
sqr_sum += input * input;
max_so_far = std::max(input, max_so_far);
}
// Strip of trailing comma.
return ret.substr(0, ret.length() - 1);
*max = max_so_far;
*mean = sum / count;
*std_dev = sqrt(std::max(0.0, count * sqr_sum - sum * sum)) / count;
}
void PrintMeanAndMax(const std::string& var_name,
const std::string& name_modifier,
const std::vector<double>& vars) {
double mean = 0.0;
double std_dev = 0.0;
double max = 0.0;
CalculateMeanAndMax(vars, &mean, &std_dev, &max);
perf_test::PrintResultMeanAndError(
kTestResultString, name_modifier, var_name + " Mean",
base::StringPrintf("%.0lf,%.0lf", mean, std_dev), "μs", true);
perf_test::PrintResult(kTestResultString, name_modifier, var_name + " Max",
base::StringPrintf("%.0lf", max), "μs", true);
}
void FindEvents(trace_analyzer::TraceAnalyzer* analyzer,
......@@ -411,36 +402,35 @@ class WebRtcVideoDisplayPerfBrowserTest
std::string smoothness_indicator =
test_config_.disable_render_smoothness_algorithm ? "_DisableSmoothness"
: "";
std::string story = base::StringPrintf(
std::string name_modifier = base::StringPrintf(
"%s_%dp%df%s", video_codec.c_str(), test_config_.height,
test_config_.fps, smoothness_indicator.c_str());
auto reporter = SetUpReporter(story);
reporter.AddResult(kMetricSkippedFramesPercent,
base::StringPrintf("%.2lf", skipped_frame_percentage_));
perf_test::PrintResult(
kTestResultString, name_modifier, "Skipped frames",
base::StringPrintf("%.2lf", skipped_frame_percentage_), "percent",
true);
// We identify intervals in a way that can help us easily bisect the source
// of added latency in case of a regression. From these intervals, "Render
// Algorithm" can take random amount of times based on the vsync cycle it is
// closest to. Therefore, "Total Controlled Latency" refers to the total
// times without that section for semi-consistent results.
reporter.AddResultList(kMetricPassingToRenderAlgoLatencyUs,
VectorToString(enqueue_frame_durations_));
reporter.AddResultList(kMetricRenderAlgoLatencyUs,
VectorToString(set_frame_durations_));
reporter.AddResultList(kMetricCompositorPickingFrameLatencyUs,
VectorToString(get_frame_durations_));
reporter.AddResultList(kMetricCompositorResourcePreparationLatencyUs,
VectorToString(resource_ready_durations_));
reporter.AddResultList(kMetricVsyncLatencyUs,
VectorToString(vsync_durations_));
reporter.AddResultList(kMetricTotalControlledLatencyUs,
VectorToString(total_controlled_durations_));
reporter.AddResultList(kMetricTotalLatencyUs,
VectorToString(total_durations_));
reporter.AddResultList(kMetricPostDecodeToRasterLatencyUs,
VectorToString(video_frame_submmitter_latencies_));
reporter.AddResultList(kMetricWebRtcDecodeLatencyUs,
VectorToString(webrtc_decode_latencies_));
PrintMeanAndMax("Passing to Render Algorithm Latency", name_modifier,
enqueue_frame_durations_);
PrintMeanAndMax("Render Algorithm Latency", name_modifier,
set_frame_durations_);
PrintMeanAndMax("Compositor Picking Frame Latency", name_modifier,
get_frame_durations_);
PrintMeanAndMax("Compositor Resource Preparation Latency", name_modifier,
resource_ready_durations_);
PrintMeanAndMax("Vsync Latency", name_modifier, vsync_durations_);
PrintMeanAndMax("Total Controlled Latency", name_modifier,
total_controlled_durations_);
PrintMeanAndMax("Total Latency", name_modifier, total_durations_);
PrintMeanAndMax("Post-decode-to-raster latency", name_modifier,
video_frame_submmitter_latencies_);
PrintMeanAndMax("WebRTC decode latency", name_modifier,
webrtc_decode_latencies_);
}
VideoDisplayPerfTestConfig test_config_;
......
chrome/browser/media/webrtc/webrtc_video_high_bitrate_browsertest.cc
View file @ 01d208fe
......@@ -12,7 +12,7 @@
#include "content/public/browser/web_contents.h"
#include "content/public/common/content_switches.h"
#include "media/base/media_switches.h"
#include "testing/perf/perf_result_reporter.h"
#include "testing/perf/perf_test.h"
#include "ui/gl/gl_switches.h"
namespace {
......@@ -22,19 +22,6 @@ static const char kMainWebrtcTestHtmlPage[] =
static const char kInboundRtp[] = "inbound-rtp";
static const char kOutboundRtp[] = "outbound-rtp";
constexpr int kBitsPerByte = 8;
constexpr char kMetricPrefixHighBitrate[] = "WebRtcHighBitrateVideo.";
constexpr char kMetricSendRateBitsPerS[] = "send_rate";
constexpr char kMetricReceiveRateBitsPerS[] = "receive_rate";
perf_test::PerfResultReporter SetUpReporter(const std::string& story) {
perf_test::PerfResultReporter reporter(kMetricPrefixHighBitrate, story);
reporter.RegisterFyiMetric(kMetricSendRateBitsPerS, "bits/s");
reporter.RegisterFyiMetric(kMetricReceiveRateBitsPerS, "bits/s");
return reporter;
}
// Sums up "RTC[In/Out]boundRTPStreamStats.bytes_[received/sent]" values.
double GetTotalRTPStreamBytes(content::TestStatsReportDictionary* report,
const char* type,
......@@ -151,10 +138,10 @@ IN_PROC_BROWSER_TEST_F(WebRtcVideoHighBitrateBrowserTest,
(video_bytes_received_after - video_bytes_received_before) /
duration_in_seconds;
auto reporter = SetUpReporter("baseline_story");
reporter.AddResult(kMetricSendRateBitsPerS, video_send_rate * kBitsPerByte);
reporter.AddResult(kMetricReceiveRateBitsPerS,
video_receive_rate * kBitsPerByte);
perf_test::PrintResult("video", "", "send_rate", video_send_rate,
"bytes/second", false);
perf_test::PrintResult("video", "", "receive_rate", video_receive_rate,
"bytes/second", false);
HangUp(left_tab);
HangUp(right_tab);
......
tools/perf/process_perf_results.py
View file @ 01d208fe
......@@ -56,7 +56,6 @@ DATA_FORMAT_UNKNOWN = 'unknown'
# are okay with potentially encountering issues.
GTEST_CONVERSION_WHITELIST = [
'angle_perftests',
'browser_tests',
'cc_perftests',
'components_perftests',
'gpu_perftests',
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment