| // Copyright 2018 The Chromium Authors |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "chrome/browser/metrics/perf/perf_events_collector.h" |
| |
| #include <stdint.h> |
| |
| #include <memory> |
| #include <string> |
| #include <utility> |
| #include <vector> |
| |
| #include "base/containers/contains.h" |
| #include "base/files/file_util.h" |
| #include "base/files/scoped_temp_dir.h" |
| #include "base/memory/ptr_util.h" |
| #include "base/metrics/field_trial_params.h" |
| #include "base/strings/string_number_conversions.h" |
| #include "base/strings/string_split.h" |
| #include "base/system/sys_info.h" |
| #include "base/test/bind.h" |
| #include "base/test/metrics/histogram_tester.h" |
| #include "base/time/time.h" |
| #include "chrome/browser/metrics/perf/cpu_identity.h" |
| #include "chrome/browser/metrics/perf/windowed_incognito_observer.h" |
| #include "components/variations/variations_associated_data.h" |
| #include "content/public/browser/browser_thread.h" |
| #include "content/public/test/browser_task_environment.h" |
| #include "testing/gtest/include/gtest/gtest.h" |
| #include "third_party/metrics_proto/sampled_profile.pb.h" |
| |
| namespace metrics { |
| |
| namespace { |
| |
| const char kPerfCommandDelimiter[] = " "; |
| |
| const char kPerfCyclesHGCmd[] = "-- record -a -e cycles:HG -c 1000003"; |
| const char kPerfFPCallgraphHGCmd[] = "-- record -a -e cycles:HG -g -c 4000037"; |
| const char kPerfLBRCallgraphCmd[] = |
| "-- record -a -e cycles -c 6000011 --call-graph lbr"; |
| const char kPerfCyclesPPPHGCmd[] = "-- record -a -e cycles:pppHG -c 1000003"; |
| const char kPerfFPCallgraphPPPHGCmd[] = |
| "-- record -a -e cycles:pppHG -g -c 4000037"; |
| const char kPerfLBRCallgraphPPPCmd[] = |
| "-- record -a -e cycles:ppp -c 6000011 --call-graph lbr"; |
| const char kPerfLBRCmd[] = "-- record -a -e r20c4 -b -c 800011"; |
| const char kPerfLBRCmdAtom[] = "-- record -a -e rc4 -b -c 800011"; |
| const char kPerfLBRCmdTremont[] = "-- record -a -e rc0c4 -b -c 800011"; |
| const char kPerfLBRCmdAlderLake[] = |
| "-- record -a -e cpu_core/r20c4/ -e cpu_atom/rc0c4/ -b -c 800011"; |
| const char kPerfITLBMissCyclesCmdIvyBridge[] = |
| "-- record -a -e itlb_misses.walk_duration -c 30001"; |
| const char kPerfITLBMissCyclesCmdSkylake[] = |
| "-- record -a -e itlb_misses.walk_pending -c 30001"; |
| const char kPerfITLBMissCyclesCmdAtom[] = |
| "-- record -a -e page_walks.i_side_cycles -c 30001"; |
| const char kPerfITLBMissCyclesCmdTremont[] = "-- record -a -e r1085 -c 30001"; |
| const char kPerfITLBMissCyclesCmdAlderLake[] = |
| "-- record -a -e cpu_core/r1011/ -e cpu_atom/r1085/ -c 30001"; |
| const char kPerfLLCMissesCmd[] = "-- record -a -e r412e -g -c 30007"; |
| const char kPerfLLCMissesPreciseCmd[] = "-- record -a -e r412e:pp -g -c 30007"; |
| const char kPerfDTLBMissesDAPGoldmont[] = |
| "-- record -a -e mem_uops_retired.dtlb_miss_loads:pp -c 2003 -d"; |
| const char kPerfDTLBMissesDAPTremont[] = "-- record -a -e r11d0:pp -c 2003 -d"; |
| const char kPerfDTLBMissesDAPHaswell[] = |
| "-- record -a -e mem_uops_retired.stlb_miss_loads:pp -c 2003 -d"; |
| const char kPerfDTLBMissesDAPSkylake[] = |
| "-- record -a -e mem_inst_retired.stlb_miss_loads:pp -c 2003 -d"; |
| |
| const char kPerfETMCmd[] = |
| "--run_inject --inject_args inject;--itrace=i512il;--strip -- record -a -e " |
| "cs_etm/autofdo/"; |
| |
| // Converts a protobuf to serialized format as a byte vector. |
| std::vector<uint8_t> SerializeMessageToVector( |
| const google::protobuf::MessageLite& message) { |
| std::vector<uint8_t> result(message.ByteSizeLong()); |
| message.SerializeToArray(result.data(), result.size()); |
| return result; |
| } |
| |
| // Returns an example PerfDataProto. The contents don't have to make sense. They |
| // just need to constitute a semantically valid protobuf. |
| // |proto| is an output parameter that will contain the created protobuf. |
| PerfDataProto GetExamplePerfDataProto() { |
| PerfDataProto proto; |
| proto.set_timestamp_sec(1435604013); // Time since epoch in seconds. |
| |
| PerfDataProto_PerfFileAttr* file_attr = proto.add_file_attrs(); |
| file_attr->add_ids(61); |
| file_attr->add_ids(62); |
| file_attr->add_ids(63); |
| |
| PerfDataProto_PerfEventAttr* attr = file_attr->mutable_attr(); |
| attr->set_type(1); |
| attr->set_size(2); |
| attr->set_config(3); |
| attr->set_sample_period(4); |
| attr->set_sample_freq(5); |
| |
| PerfDataProto_PerfEventStats* stats = proto.mutable_stats(); |
| stats->set_num_events_read(100); |
| stats->set_num_sample_events(200); |
| stats->set_num_mmap_events(300); |
| stats->set_num_fork_events(400); |
| stats->set_num_exit_events(500); |
| |
| return proto; |
| } |
| |
| base::TimeDelta GetDuration(const std::vector<std::string>& quipper_args) { |
| for (auto it = quipper_args.begin(); it != quipper_args.end(); ++it) { |
| if (*it == "--duration" && it != quipper_args.end()) { |
| int dur; |
| if (base::StringToInt(*(it + 1), &dur)) |
| return base::Seconds(dur); |
| } |
| } |
| return base::Seconds(0); |
| } |
| |
| // A mock PerfOutputCall class for testing, which outputs example perf data |
| // after the profile duration elapses. |
| class FakePerfOutputCall : public PerfOutputCall { |
| public: |
| using PerfOutputCall::DoneCallback; |
| FakePerfOutputCall(base::TimeDelta duration, |
| DoneCallback done_callback, |
| base::OnceClosure on_stop) |
| : PerfOutputCall(), |
| done_callback_(std::move(done_callback)), |
| on_stop_(std::move(on_stop)) { |
| // Simulates collection done after profiling duration. |
| collection_done_timer_.Start(FROM_HERE, duration, this, |
| &FakePerfOutputCall::OnCollectionDone); |
| } |
| |
| FakePerfOutputCall(const FakePerfOutputCall&) = delete; |
| FakePerfOutputCall& operator=(const FakePerfOutputCall&) = delete; |
| |
| ~FakePerfOutputCall() override = default; |
| |
| void Stop() override { |
| // Notify the observer that Stop() is called. |
| std::move(on_stop_).Run(); |
| |
| // Simulates that collection is done when we stop the perf session. Note |
| // that this may destroy |this| and should be the last action in Stop(). |
| if (collection_done_timer_.IsRunning()) |
| collection_done_timer_.FireNow(); |
| } |
| |
| private: |
| void OnCollectionDone() { |
| std::move(done_callback_) |
| .Run(GetExamplePerfDataProto().SerializeAsString()); |
| } |
| |
| DoneCallback done_callback_; |
| base::OneShotTimer collection_done_timer_; |
| base::OnceClosure on_stop_; |
| }; |
| |
| // Allows testing of PerfCollector behavior when an incognito window is opened. |
| class TestIncognitoObserver : public WindowedIncognitoObserver { |
| public: |
| // Factory function to create a TestIncognitoObserver object contained in a |
| // std::unique_ptr<WindowedIncognitoObserver> object. |incognito_launched| |
| // simulates the presence of an open incognito window, or the lack thereof. |
| // Used for passing observers to ParseOutputProtoIfValid(). |
| static std::unique_ptr<WindowedIncognitoObserver> CreateWithIncognitoLaunched( |
| bool incognito_launched) { |
| return base::WrapUnique(new TestIncognitoObserver(incognito_launched)); |
| } |
| |
| TestIncognitoObserver(const TestIncognitoObserver&) = delete; |
| TestIncognitoObserver& operator=(const TestIncognitoObserver&) = delete; |
| |
| bool IncognitoLaunched() const override { return incognito_launched_; } |
| |
| private: |
| explicit TestIncognitoObserver(bool incognito_launched) |
| : WindowedIncognitoObserver(nullptr, 0), |
| incognito_launched_(incognito_launched) {} |
| |
| bool incognito_launched_; |
| }; |
| |
| // Allows access to some private methods for testing. |
| class TestPerfCollector : public PerfCollector { |
| public: |
| TestPerfCollector() = default; |
| |
| TestPerfCollector(const TestPerfCollector&) = delete; |
| TestPerfCollector& operator=(const TestPerfCollector&) = delete; |
| |
| using MetricCollector::CollectionAttemptStatus; |
| using MetricCollector::CollectPerfDataAfterSessionRestore; |
| using MetricCollector::OnJankStarted; |
| using MetricCollector::OnJankStopped; |
| using MetricCollector::ShouldCollect; |
| using MetricCollector::StopTimer; |
| using PerfCollector::AddCachedDataDelta; |
| using PerfCollector::collection_params; |
| using PerfCollector::CollectPSICPU; |
| using PerfCollector::command_selector; |
| using PerfCollector::CommandEventType; |
| using PerfCollector::EventType; |
| using PerfCollector::Init; |
| using PerfCollector::IsRunning; |
| using PerfCollector::LacrosChannelAndVersion; |
| using PerfCollector::max_frequencies_mhz; |
| using PerfCollector::ParseLacrosPath; |
| using PerfCollector::ParseOutputProtoIfValid; |
| using PerfCollector::ParsePSICPUStatus; |
| using PerfCollector::RecordUserLogin; |
| using PerfCollector::set_profile_done_callback; |
| |
| bool collection_stopped() { return collection_stopped_; } |
| bool collection_done() { return !real_callback_; } |
| |
| base::TimeDelta elapsed_duration; |
| |
| protected: |
| std::unique_ptr<PerfOutputCall> CreatePerfOutputCall( |
| const std::vector<std::string>& quipper_args, |
| bool disable_cpu_idle, |
| PerfOutputCall::DoneCallback callback) override { |
| real_callback_ = std::move(callback); |
| elapsed_duration = GetDuration(quipper_args); |
| |
| return std::make_unique<FakePerfOutputCall>( |
| elapsed_duration, |
| base::BindOnce(&TestPerfCollector::OnCollectionDone, |
| base::Unretained(this)), |
| base::BindOnce(&TestPerfCollector::OnCollectionStopped, |
| base::Unretained(this))); |
| } |
| |
| void OnCollectionDone(std::string perf_output) { |
| std::move(real_callback_).Run(std::move(perf_output)); |
| } |
| |
| void OnCollectionStopped() { collection_stopped_ = true; } |
| |
| PerfOutputCall::DoneCallback real_callback_; |
| bool collection_stopped_ = false; |
| }; |
| |
| const base::TimeDelta kPeriodicCollectionInterval = base::Hours(1); |
| const base::TimeDelta kCollectionDuration = base::Seconds(2); |
| |
| // A wrapper around CommandEventType, to test if a perf command samples |
| // the cycles event. The wrapper takes a command as a string, while the |
| // wrapped CommandEventType takes the command split into words. |
| bool DoesCommandSampleCycles(std::string command) { |
| using EventType = TestPerfCollector::EventType; |
| std::vector<std::string> cmd_args = |
| base::SplitString(command, kPerfCommandDelimiter, base::KEEP_WHITESPACE, |
| base::SPLIT_WANT_ALL); |
| return TestPerfCollector::CommandEventType(cmd_args) == EventType::kCycles; |
| } |
| |
| // A wrapper around CommandEventType, to test if a perf command samples |
| // the etm event. The wrapper takes a command as a string, while the |
| // wrapped CommandEventType takes the command split into words. |
| bool DoesCommandSampleETM(std::string command) { |
| using EventType = TestPerfCollector::EventType; |
| std::vector<std::string> cmd_args = |
| base::SplitString(command, kPerfCommandDelimiter, base::KEEP_WHITESPACE, |
| base::SPLIT_WANT_ALL); |
| return TestPerfCollector::CommandEventType(cmd_args) == EventType::kETM; |
| } |
| |
| } // namespace |
| |
| class PerfCollectorTest : public testing::Test { |
| public: |
| PerfCollectorTest() |
| : task_environment_(base::test::TaskEnvironment::TimeSource::MOCK_TIME) {} |
| |
| PerfCollectorTest(const PerfCollectorTest&) = delete; |
| PerfCollectorTest& operator=(const PerfCollectorTest&) = delete; |
| |
| void SaveProfile(std::unique_ptr<SampledProfile> sampled_profile) { |
| cached_profile_data_.resize(cached_profile_data_.size() + 1); |
| cached_profile_data_.back().Swap(sampled_profile.get()); |
| } |
| |
| void SetUp() override { |
| perf_collector_ = std::make_unique<TestPerfCollector>(); |
| // Set the periodic collection delay to a well known quantity, so we can |
| // fast forward the time. |
| perf_collector_->collection_params().periodic_interval = |
| kPeriodicCollectionInterval; |
| // Set collection duration to a known quantity for fast forwarding time. |
| perf_collector_->collection_params().collection_duration = |
| kCollectionDuration; |
| |
| perf_collector_->set_profile_done_callback(base::BindRepeating( |
| &PerfCollectorTest::SaveProfile, base::Unretained(this))); |
| |
| perf_collector_->Init(); |
| // PerfCollector requires the user to be logged in. |
| perf_collector_->RecordUserLogin(base::TimeTicks::Now()); |
| |
| perf_collector_->elapsed_duration = base::Seconds(0); |
| } |
| |
| void TearDown() override { |
| perf_collector_.reset(); |
| cached_profile_data_.clear(); |
| } |
| |
| protected: |
| // task_environment_ must be the first member (or at least before |
| // any member that cares about tasks) to be initialized first and destroyed |
| // last. |
| content::BrowserTaskEnvironment task_environment_; |
| |
| std::vector<SampledProfile> cached_profile_data_; |
| |
| std::unique_ptr<TestPerfCollector> perf_collector_; |
| }; |
| |
| TEST_F(PerfCollectorTest, CheckSetup) { |
| // No profiles saved at start. |
| EXPECT_TRUE(cached_profile_data_.empty()); |
| |
| EXPECT_FALSE(TestIncognitoObserver::CreateWithIncognitoLaunched(false) |
| ->IncognitoLaunched()); |
| EXPECT_TRUE(TestIncognitoObserver::CreateWithIncognitoLaunched(true) |
| ->IncognitoLaunched()); |
| task_environment_.RunUntilIdle(); |
| EXPECT_GT(perf_collector_->max_frequencies_mhz().size(), 0u); |
| } |
| |
| TEST_F(PerfCollectorTest, PrependDuration) { |
| // Timer is active after login and a periodic collection is scheduled. |
| EXPECT_TRUE(perf_collector_->IsRunning()); |
| base::HistogramTester histogram_tester; |
| |
| // Advance the clock by a periodic collection interval to trigger |
| // a collection. |
| task_environment_.FastForwardBy(kPeriodicCollectionInterval); |
| EXPECT_EQ(perf_collector_->elapsed_duration, kCollectionDuration); |
| histogram_tester.ExpectUniqueSample( |
| "ChromeOS.CWP.CollectPerf", |
| TestPerfCollector::CollectionAttemptStatus::SUCCESS, 1); |
| } |
| |
| TEST_F(PerfCollectorTest, NoCollectionWhenProfileCacheFull) { |
| // Timer is active after login and a periodic collection is scheduled. |
| EXPECT_TRUE(perf_collector_->IsRunning()); |
| // Pretend the cache is full. |
| perf_collector_->AddCachedDataDelta(4 * 1024 * 1024); |
| base::HistogramTester histogram_tester; |
| |
| // Advance the clock by a periodic collection interval. We shouldn't find a |
| // profile because the cache is full. |
| task_environment_.FastForwardBy(kPeriodicCollectionInterval); |
| EXPECT_TRUE(cached_profile_data_.empty()); |
| histogram_tester.ExpectUniqueSample( |
| "ChromeOS.CWP.CollectPerf", |
| TestPerfCollector::CollectionAttemptStatus::NOT_READY_TO_COLLECT, 1); |
| } |
| |
| // Simulate opening and closing of incognito window in between calls to |
| // ParseOutputProtoIfValid(). |
| TEST_F(PerfCollectorTest, IncognitoWindowOpened) { |
| PerfDataProto perf_data_proto = GetExamplePerfDataProto(); |
| EXPECT_GT(perf_data_proto.ByteSizeLong(), 0U); |
| task_environment_.RunUntilIdle(); |
| |
| auto sampled_profile = std::make_unique<SampledProfile>(); |
| sampled_profile->set_trigger_event(SampledProfile::PERIODIC_COLLECTION); |
| |
| auto incognito_observer = |
| TestIncognitoObserver::CreateWithIncognitoLaunched(false); |
| perf_collector_->ParseOutputProtoIfValid(std::move(incognito_observer), |
| std::move(sampled_profile), true, |
| perf_data_proto.SerializeAsString()); |
| |
| // Run the BrowserTaskEnvironment queue until it's empty as the above |
| // ParseOutputProtoIfValid call posts a task to asynchronously collect process |
| // and thread types and the profile cache will be updated asynchronously via |
| // another PostTask request after this collection completes. |
| task_environment_.RunUntilIdle(); |
| |
| ASSERT_EQ(1U, cached_profile_data_.size()); |
| |
| const SampledProfile& profile1 = cached_profile_data_[0]; |
| EXPECT_EQ(SampledProfile::PERIODIC_COLLECTION, profile1.trigger_event()); |
| EXPECT_TRUE(profile1.has_ms_after_login()); |
| ASSERT_TRUE(profile1.has_perf_data()); |
| EXPECT_EQ(SerializeMessageToVector(perf_data_proto), |
| SerializeMessageToVector(profile1.perf_data())); |
| EXPECT_GT(profile1.cpu_max_frequency_mhz_size(), 0); |
| cached_profile_data_.clear(); |
| |
| base::HistogramTester histogram_tester; |
| sampled_profile = std::make_unique<SampledProfile>(); |
| sampled_profile->set_trigger_event(SampledProfile::RESUME_FROM_SUSPEND); |
| // An incognito window opens. |
| incognito_observer = TestIncognitoObserver::CreateWithIncognitoLaunched(true); |
| perf_collector_->ParseOutputProtoIfValid(std::move(incognito_observer), |
| std::move(sampled_profile), true, |
| perf_data_proto.SerializeAsString()); |
| task_environment_.RunUntilIdle(); |
| |
| EXPECT_TRUE(cached_profile_data_.empty()); |
| histogram_tester.ExpectUniqueSample( |
| "ChromeOS.CWP.CollectPerf", |
| TestPerfCollector::CollectionAttemptStatus::INCOGNITO_LAUNCHED, 1); |
| |
| sampled_profile = std::make_unique<SampledProfile>(); |
| sampled_profile->set_trigger_event(SampledProfile::RESUME_FROM_SUSPEND); |
| sampled_profile->set_suspend_duration_ms(60000); |
| sampled_profile->set_ms_after_resume(1500); |
| // Incognito window closes. |
| incognito_observer = |
| TestIncognitoObserver::CreateWithIncognitoLaunched(false); |
| perf_collector_->ParseOutputProtoIfValid(std::move(incognito_observer), |
| std::move(sampled_profile), true, |
| perf_data_proto.SerializeAsString()); |
| task_environment_.RunUntilIdle(); |
| |
| ASSERT_EQ(1U, cached_profile_data_.size()); |
| |
| const SampledProfile& profile2 = cached_profile_data_[0]; |
| EXPECT_EQ(SampledProfile::RESUME_FROM_SUSPEND, profile2.trigger_event()); |
| EXPECT_TRUE(profile2.has_ms_after_login()); |
| EXPECT_EQ(60000, profile2.suspend_duration_ms()); |
| EXPECT_EQ(1500, profile2.ms_after_resume()); |
| ASSERT_TRUE(profile2.has_perf_data()); |
| EXPECT_EQ(SerializeMessageToVector(perf_data_proto), |
| SerializeMessageToVector(profile2.perf_data())); |
| EXPECT_GT(profile2.cpu_max_frequency_mhz_size(), 0); |
| } |
| |
| TEST_F(PerfCollectorTest, CollectPSICPUDataSuccess) { |
| base::ScopedTempDir tmp_dir; |
| ASSERT_TRUE(tmp_dir.CreateUniqueTempDir()); |
| base::FilePath psi_cpu_file = tmp_dir.GetPath().Append("psi_cpu"); |
| ASSERT_TRUE(base::WriteFile( |
| psi_cpu_file, "some avg10=2.04 avg60=0.75 avg300=0.40 total=1576")); |
| |
| base::HistogramTester histogram_tester; |
| |
| auto sampled_profile = std::make_unique<SampledProfile>(); |
| TestPerfCollector::CollectPSICPU(sampled_profile.get(), psi_cpu_file.value()); |
| |
| EXPECT_FLOAT_EQ(sampled_profile->psi_cpu_last_10s_pct(), 2.04); |
| EXPECT_FLOAT_EQ(sampled_profile->psi_cpu_last_60s_pct(), 0.75); |
| histogram_tester.ExpectUniqueSample( |
| "ChromeOS.CWP.ParsePSICPU", |
| TestPerfCollector::ParsePSICPUStatus::kSuccess, 1); |
| } |
| |
| TEST_F(PerfCollectorTest, CollectPSICPUDataReadFileFailed) { |
| const char kPSICPUPath[] = "/some/random/path"; |
| base::HistogramTester histogram_tester; |
| |
| auto sampled_profile = std::make_unique<SampledProfile>(); |
| TestPerfCollector::CollectPSICPU(sampled_profile.get(), kPSICPUPath); |
| |
| EXPECT_FALSE(sampled_profile->has_psi_cpu_last_10s_pct()); |
| EXPECT_FALSE(sampled_profile->has_psi_cpu_last_60s_pct()); |
| histogram_tester.ExpectUniqueSample( |
| "ChromeOS.CWP.ParsePSICPU", |
| TestPerfCollector::ParsePSICPUStatus::kReadFileFailed, 1); |
| } |
| |
| TEST_F(PerfCollectorTest, CollectPSICPUDataUnexpectedDataFormat) { |
| base::ScopedTempDir tmp_dir; |
| ASSERT_TRUE(tmp_dir.CreateUniqueTempDir()); |
| base::FilePath psi_cpu_file = tmp_dir.GetPath().Append("psi_cpu"); |
| ASSERT_TRUE(base::WriteFile(psi_cpu_file, "random content")); |
| |
| base::HistogramTester histogram_tester; |
| |
| auto sampled_profile = std::make_unique<SampledProfile>(); |
| TestPerfCollector::CollectPSICPU(sampled_profile.get(), psi_cpu_file.value()); |
| |
| EXPECT_FALSE(sampled_profile->has_psi_cpu_last_10s_pct()); |
| EXPECT_FALSE(sampled_profile->has_psi_cpu_last_60s_pct()); |
| histogram_tester.ExpectUniqueSample( |
| "ChromeOS.CWP.ParsePSICPU", |
| TestPerfCollector::ParsePSICPUStatus::kUnexpectedDataFormat, 1); |
| } |
| |
| TEST_F(PerfCollectorTest, DefaultCommandsBasedOnUarch_IvyBridge) { |
| CPUIdentity cpuid; |
| cpuid.arch = "x86_64"; |
| cpuid.vendor = "GenuineIntel"; |
| cpuid.family = 0x06; |
| cpuid.model = 0x3a; // IvyBridge |
| cpuid.model_name = ""; |
| cpuid.release = "3.8.11"; |
| std::vector<RandomSelector::WeightAndValue> cmds = |
| internal::GetDefaultCommandsForCpuModel(cpuid, ""); |
| ASSERT_GE(cmds.size(), 2UL); |
| EXPECT_EQ(cmds[0].value, kPerfCyclesHGCmd); |
| EXPECT_TRUE(DoesCommandSampleCycles(cmds[0].value)); |
| EXPECT_EQ(cmds[1].value, kPerfFPCallgraphHGCmd); |
| EXPECT_TRUE(DoesCommandSampleCycles(cmds[1].value)); |
| EXPECT_TRUE(base::Contains(cmds, kPerfLBRCmd, |
| &RandomSelector::WeightAndValue::value)); |
| EXPECT_TRUE(base::Contains(cmds, kPerfLLCMissesCmd, |
| &RandomSelector::WeightAndValue::value)); |
| EXPECT_TRUE(base::Contains(cmds, kPerfITLBMissCyclesCmdIvyBridge, |
| &RandomSelector::WeightAndValue::value)); |
| } |
| |
| TEST_F(PerfCollectorTest, DefaultCommandsBasedOnUarch_SandyBridge) { |
| CPUIdentity cpuid; |
| cpuid.arch = "x86_64"; |
| cpuid.vendor = "GenuineIntel"; |
| cpuid.family = 0x06; |
| cpuid.model = 0x2a; // SandyBridge |
| cpuid.model_name = ""; |
| cpuid.release = "3.8.11"; |
| std::vector<RandomSelector::WeightAndValue> cmds = |
| internal::GetDefaultCommandsForCpuModel(cpuid, ""); |
| ASSERT_GE(cmds.size(), 2UL); |
| EXPECT_EQ(cmds[0].value, kPerfCyclesHGCmd); |
| EXPECT_TRUE(DoesCommandSampleCycles(cmds[0].value)); |
| EXPECT_EQ(cmds[1].value, kPerfFPCallgraphHGCmd); |
| EXPECT_TRUE(DoesCommandSampleCycles(cmds[1].value)); |
| EXPECT_TRUE(base::Contains(cmds, kPerfLBRCmd, |
| &RandomSelector::WeightAndValue::value)); |
| EXPECT_TRUE(base::Contains(cmds, kPerfLLCMissesCmd, |
| &RandomSelector::WeightAndValue::value)); |
| EXPECT_TRUE(base::Contains(cmds, kPerfITLBMissCyclesCmdIvyBridge, |
| &RandomSelector::WeightAndValue::value)); |
| } |
| |
| TEST_F(PerfCollectorTest, DefaultCommandsBasedOnUarch_Haswell) { |
| CPUIdentity cpuid; |
| cpuid.arch = "x86_64"; |
| cpuid.vendor = "GenuineIntel"; |
| cpuid.family = 0x06; |
| cpuid.model = 0x45; // Haswell |
| cpuid.model_name = ""; |
| cpuid.release = "3.8.11"; |
| std::vector<RandomSelector::WeightAndValue> cmds = |
| internal::GetDefaultCommandsForCpuModel(cpuid, ""); |
| ASSERT_GE(cmds.size(), 2UL); |
| EXPECT_EQ(cmds[0].value, kPerfCyclesHGCmd); |
| EXPECT_TRUE(DoesCommandSampleCycles(cmds[0].value)); |
| EXPECT_EQ(cmds[1].value, kPerfFPCallgraphHGCmd); |
| EXPECT_TRUE(DoesCommandSampleCycles(cmds[1].value)); |
| // No LBR callstacks because the kernel is old. |
| EXPECT_FALSE(base::Contains(cmds, kPerfLBRCallgraphCmd, |
| &RandomSelector::WeightAndValue::value)); |
| EXPECT_TRUE(base::Contains(cmds, kPerfLBRCmd, |
| &RandomSelector::WeightAndValue::value)); |
| EXPECT_TRUE(base::Contains(cmds, kPerfLLCMissesCmd, |
| &RandomSelector::WeightAndValue::value)); |
| EXPECT_TRUE(base::Contains(cmds, kPerfITLBMissCyclesCmdIvyBridge, |
| &RandomSelector::WeightAndValue::value)); |
| EXPECT_TRUE(base::Contains(cmds, kPerfDTLBMissesDAPHaswell, |
| &RandomSelector::WeightAndValue::value)); |
| } |
| |
| TEST_F(PerfCollectorTest, DefaultCommandsBasedOnUarch_Skylake) { |
| CPUIdentity cpuid; |
| cpuid.arch = "x86_64"; |
| cpuid.vendor = "GenuineIntel"; |
| cpuid.family = 0x06; |
| cpuid.model = 0x4E; // Skylake |
| cpuid.model_name = ""; |
| cpuid.release = "3.18.0"; |
| std::vector<RandomSelector::WeightAndValue> cmds = |
| internal::GetDefaultCommandsForCpuModel(cpuid, ""); |
| ASSERT_GE(cmds.size(), 3UL); |
| EXPECT_EQ(cmds[0].value, kPerfCyclesHGCmd); |
| // We have both FP and LBR based callstacks. |
| EXPECT_EQ(cmds[1].value, kPerfFPCallgraphHGCmd); |
| EXPECT_TRUE(DoesCommandSampleCycles(cmds[0].value)); |
| EXPECT_EQ(cmds[2].value, kPerfLBRCallgraphCmd); |
| EXPECT_TRUE(DoesCommandSampleCycles(cmds[1].value)); |
| EXPECT_TRUE(base::Contains(cmds, kPerfLBRCmd, |
| &RandomSelector::WeightAndValue::value)); |
| EXPECT_TRUE(base::Contains(cmds, kPerfLLCMissesCmd, |
| &RandomSelector::WeightAndValue::value)); |
| EXPECT_TRUE(base::Contains(cmds, kPerfITLBMissCyclesCmdSkylake, |
| &RandomSelector::WeightAndValue::value)); |
| EXPECT_TRUE(base::Contains(cmds, kPerfDTLBMissesDAPSkylake, |
| &RandomSelector::WeightAndValue::value)); |
| } |
| |
| TEST_F(PerfCollectorTest, DefaultCommandsBasedOnUarch_Tigerlake) { |
| CPUIdentity cpuid; |
| cpuid.arch = "x86_64"; |
| cpuid.vendor = "GenuineIntel"; |
| cpuid.family = 0x06; |
| cpuid.model = 0x8C; // Tigerlake |
| cpuid.model_name = ""; |
| cpuid.release = "5.4.64"; |
| std::vector<RandomSelector::WeightAndValue> cmds = |
| internal::GetDefaultCommandsForCpuModel(cpuid, ""); |
| ASSERT_GE(cmds.size(), 3UL); |
| EXPECT_EQ(cmds[0].value, kPerfCyclesPPPHGCmd); |
| // We have both FP and LBR based callstacks. |
| EXPECT_EQ(cmds[1].value, kPerfFPCallgraphPPPHGCmd); |
| EXPECT_TRUE(DoesCommandSampleCycles(cmds[0].value)); |
| EXPECT_EQ(cmds[2].value, kPerfLBRCallgraphPPPCmd); |
| EXPECT_TRUE(DoesCommandSampleCycles(cmds[1].value)); |
| EXPECT_TRUE(base::Contains(cmds, kPerfLBRCmd, |
| &RandomSelector::WeightAndValue::value)); |
| EXPECT_TRUE(base::Contains(cmds, kPerfLLCMissesCmd, |
| &RandomSelector::WeightAndValue::value)); |
| EXPECT_TRUE(base::Contains(cmds, kPerfITLBMissCyclesCmdSkylake, |
| &RandomSelector::WeightAndValue::value)); |
| EXPECT_TRUE(base::Contains(cmds, kPerfDTLBMissesDAPSkylake, |
| &RandomSelector::WeightAndValue::value)); |
| } |
| |
| TEST_F(PerfCollectorTest, DefaultCommandsBasedOnUarch_Goldmont) { |
| CPUIdentity cpuid; |
| cpuid.arch = "x86_64"; |
| cpuid.vendor = "GenuineIntel"; |
| cpuid.family = 0x06; |
| cpuid.model = 0x5c; // Goldmont |
| cpuid.model_name = ""; |
| cpuid.release = "4.4.196"; |
| std::vector<RandomSelector::WeightAndValue> cmds = |
| internal::GetDefaultCommandsForCpuModel(cpuid, ""); |
| ASSERT_GE(cmds.size(), 2UL); |
| EXPECT_EQ(cmds[0].value, kPerfCyclesHGCmd); |
| EXPECT_TRUE(DoesCommandSampleCycles(cmds[0].value)); |
| EXPECT_EQ(cmds[1].value, kPerfFPCallgraphPPPHGCmd); |
| EXPECT_TRUE(DoesCommandSampleCycles(cmds[1].value)); |
| // No LBR callstacks because the microarchitecture doesn't support it. |
| EXPECT_FALSE(base::Contains(cmds, kPerfLBRCallgraphCmd, |
| &RandomSelector::WeightAndValue::value)); |
| EXPECT_TRUE(base::Contains(cmds, kPerfLBRCmdAtom, |
| &RandomSelector::WeightAndValue::value)); |
| EXPECT_TRUE(base::Contains(cmds, kPerfLLCMissesPreciseCmd, |
| &RandomSelector::WeightAndValue::value)); |
| EXPECT_TRUE(base::Contains(cmds, kPerfITLBMissCyclesCmdAtom, |
| &RandomSelector::WeightAndValue::value)); |
| EXPECT_TRUE(base::Contains(cmds, kPerfDTLBMissesDAPGoldmont, |
| &RandomSelector::WeightAndValue::value)); |
| } |
| |
| TEST_F(PerfCollectorTest, DefaultCommandsBasedOnUarch_GoldmontPlus) { |
| CPUIdentity cpuid; |
| cpuid.arch = "x86_64"; |
| cpuid.vendor = "GenuineIntel"; |
| cpuid.family = 0x06; |
| cpuid.model = 0x7a; // GoldmontPlus |
| cpuid.model_name = ""; |
| cpuid.release = "4.14.214"; |
| std::vector<RandomSelector::WeightAndValue> cmds = |
| internal::GetDefaultCommandsForCpuModel(cpuid, ""); |
| ASSERT_GE(cmds.size(), 2UL); |
| EXPECT_EQ(cmds[0].value, kPerfCyclesPPPHGCmd); |
| EXPECT_TRUE(DoesCommandSampleCycles(cmds[0].value)); |
| EXPECT_EQ(cmds[1].value, kPerfFPCallgraphPPPHGCmd); |
| EXPECT_TRUE(DoesCommandSampleCycles(cmds[1].value)); |
| // No LBR callstacks because the microarchitecture doesn't support it. |
| EXPECT_FALSE(base::Contains(cmds, kPerfLBRCallgraphCmd, |
| &RandomSelector::WeightAndValue::value)); |
| EXPECT_TRUE(base::Contains(cmds, kPerfLBRCmdAtom, |
| &RandomSelector::WeightAndValue::value)); |
| EXPECT_TRUE(base::Contains(cmds, kPerfLLCMissesPreciseCmd, |
| &RandomSelector::WeightAndValue::value)); |
| EXPECT_TRUE(base::Contains(cmds, kPerfITLBMissCyclesCmdSkylake, |
| &RandomSelector::WeightAndValue::value)); |
| EXPECT_TRUE(base::Contains(cmds, kPerfDTLBMissesDAPGoldmont, |
| &RandomSelector::WeightAndValue::value)); |
| } |
| |
| TEST_F(PerfCollectorTest, DefaultCommandsBasedOnUarch_Tremont) { |
| CPUIdentity cpuid; |
| cpuid.arch = "x86_64"; |
| cpuid.vendor = "GenuineIntel"; |
| cpuid.family = 0x06; |
| cpuid.model = 0x9c; // Tremont |
| cpuid.model_name = ""; |
| cpuid.release = "5.4.206"; |
| std::vector<RandomSelector::WeightAndValue> cmds = |
| internal::GetDefaultCommandsForCpuModel(cpuid, ""); |
| ASSERT_GE(cmds.size(), 2UL); |
| EXPECT_EQ(cmds[0].value, kPerfCyclesPPPHGCmd); |
| EXPECT_TRUE(DoesCommandSampleCycles(cmds[0].value)); |
| EXPECT_EQ(cmds[1].value, kPerfFPCallgraphPPPHGCmd); |
| EXPECT_TRUE(DoesCommandSampleCycles(cmds[1].value)); |
| EXPECT_TRUE(base::Contains(cmds, kPerfLBRCallgraphPPPCmd, |
| &RandomSelector::WeightAndValue::value)); |
| EXPECT_TRUE(base::Contains(cmds, kPerfLBRCmdTremont, |
| &RandomSelector::WeightAndValue::value)); |
| EXPECT_TRUE(base::Contains(cmds, kPerfLLCMissesPreciseCmd, |
| &RandomSelector::WeightAndValue::value)); |
| EXPECT_TRUE(base::Contains(cmds, kPerfITLBMissCyclesCmdTremont, |
| &RandomSelector::WeightAndValue::value)); |
| EXPECT_TRUE(base::Contains(cmds, kPerfDTLBMissesDAPTremont, |
| &RandomSelector::WeightAndValue::value)); |
| } |
| |
| TEST_F(PerfCollectorTest, DefaultCommandsBasedOnUarch_AlderLake) { |
| CPUIdentity cpuid; |
| cpuid.arch = "x86_64"; |
| cpuid.vendor = "GenuineIntel"; |
| cpuid.family = 0x06; |
| cpuid.model = 0x9a; // AlderLake |
| cpuid.model_name = ""; |
| cpuid.release = "6.6.30"; |
| std::vector<RandomSelector::WeightAndValue> cmds = |
| internal::GetDefaultCommandsForCpuModel(cpuid, ""); |
| ASSERT_GE(cmds.size(), 2UL); |
| EXPECT_EQ(cmds[0].value, kPerfCyclesPPPHGCmd); |
| EXPECT_TRUE(DoesCommandSampleCycles(cmds[0].value)); |
| EXPECT_EQ(cmds[1].value, kPerfFPCallgraphPPPHGCmd); |
| EXPECT_TRUE(DoesCommandSampleCycles(cmds[1].value)); |
| EXPECT_TRUE(base::Contains(cmds, kPerfLBRCallgraphPPPCmd, |
| &RandomSelector::WeightAndValue::value)); |
| EXPECT_TRUE(base::Contains(cmds, kPerfLBRCmdAlderLake, |
| &RandomSelector::WeightAndValue::value)); |
| EXPECT_TRUE(base::Contains(cmds, kPerfLLCMissesPreciseCmd, |
| &RandomSelector::WeightAndValue::value)); |
| EXPECT_TRUE(base::Contains(cmds, kPerfITLBMissCyclesCmdAlderLake, |
| &RandomSelector::WeightAndValue::value)); |
| EXPECT_TRUE(base::Contains(cmds, kPerfDTLBMissesDAPTremont, |
| &RandomSelector::WeightAndValue::value)); |
| } |
| |
| TEST_F(PerfCollectorTest, DefaultCommandsBasedOnUarch_Gracemont) { |
| CPUIdentity cpuid; |
| cpuid.arch = "x86_64"; |
| cpuid.vendor = "GenuineIntel"; |
| cpuid.family = 0x06; |
| cpuid.model = 0xbe; // Gracemont |
| cpuid.model_name = ""; |
| cpuid.release = "6.6.30"; |
| std::vector<RandomSelector::WeightAndValue> cmds = |
| internal::GetDefaultCommandsForCpuModel(cpuid, ""); |
| ASSERT_GE(cmds.size(), 2UL); |
| EXPECT_EQ(cmds[0].value, kPerfCyclesPPPHGCmd); |
| EXPECT_TRUE(DoesCommandSampleCycles(cmds[0].value)); |
| EXPECT_EQ(cmds[1].value, kPerfFPCallgraphPPPHGCmd); |
| EXPECT_TRUE(DoesCommandSampleCycles(cmds[1].value)); |
| EXPECT_TRUE(base::Contains(cmds, kPerfLBRCallgraphPPPCmd, |
| &RandomSelector::WeightAndValue::value)); |
| EXPECT_TRUE(base::Contains(cmds, kPerfLBRCmdTremont, |
| &RandomSelector::WeightAndValue::value)); |
| EXPECT_TRUE(base::Contains(cmds, kPerfLLCMissesPreciseCmd, |
| &RandomSelector::WeightAndValue::value)); |
| EXPECT_TRUE(base::Contains(cmds, kPerfITLBMissCyclesCmdTremont, |
| &RandomSelector::WeightAndValue::value)); |
| EXPECT_TRUE(base::Contains(cmds, kPerfDTLBMissesDAPTremont, |
| &RandomSelector::WeightAndValue::value)); |
| } |
| |
| TEST_F(PerfCollectorTest, DefaultCommandsBasedOnUarch_Excavator) { |
| CPUIdentity cpuid; |
| cpuid.arch = "x86_64"; |
| cpuid.vendor = "AuthenticAMD"; |
| cpuid.family = 0x15; |
| cpuid.model = 0x70; // Excavator |
| cpuid.model_name = ""; |
| std::vector<RandomSelector::WeightAndValue> cmds = |
| internal::GetDefaultCommandsForCpuModel(cpuid, ""); |
| ASSERT_GE(cmds.size(), 2UL); |
| EXPECT_EQ(cmds[0].value, kPerfCyclesHGCmd); |
| EXPECT_TRUE(DoesCommandSampleCycles(cmds[0].value)); |
| EXPECT_EQ(cmds[1].value, kPerfFPCallgraphHGCmd); |
| EXPECT_TRUE(DoesCommandSampleCycles(cmds[1].value)); |
| EXPECT_FALSE(base::Contains(cmds, kPerfLLCMissesCmd, |
| &RandomSelector::WeightAndValue::value)) |
| << "Excavator does not support this command"; |
| } |
| |
| TEST_F(PerfCollectorTest, DefaultCommandsBasedOnArch_Arm32) { |
| CPUIdentity cpuid; |
| cpuid.arch = "armv7l"; |
| cpuid.vendor = ""; |
| cpuid.family = 0; |
| cpuid.model = 0; |
| cpuid.model_name = ""; |
| std::vector<RandomSelector::WeightAndValue> cmds = |
| internal::GetDefaultCommandsForCpuModel(cpuid, ""); |
| ASSERT_GE(cmds.size(), 2UL); |
| EXPECT_EQ(cmds[0].value, kPerfCyclesHGCmd); |
| EXPECT_TRUE(DoesCommandSampleCycles(cmds[0].value)); |
| EXPECT_EQ(cmds[1].value, kPerfFPCallgraphHGCmd); |
| EXPECT_TRUE(DoesCommandSampleCycles(cmds[1].value)); |
| EXPECT_FALSE( |
| base::Contains(cmds, kPerfLBRCmd, &RandomSelector::WeightAndValue::value)) |
| << "ARM32 does not support this command"; |
| EXPECT_FALSE(base::Contains(cmds, kPerfLLCMissesCmd, |
| &RandomSelector::WeightAndValue::value)) |
| << "ARM32 does not support this command"; |
| } |
| |
| TEST_F(PerfCollectorTest, DefaultCommandsBasedOnArch_Arm64) { |
| CPUIdentity cpuid; |
| cpuid.arch = "aarch64"; |
| cpuid.vendor = ""; |
| cpuid.family = 0; |
| cpuid.model = 0; |
| cpuid.model_name = ""; |
| std::vector<RandomSelector::WeightAndValue> cmds = |
| internal::GetDefaultCommandsForCpuModel(cpuid, ""); |
| ASSERT_GE(cmds.size(), 2UL); |
| EXPECT_EQ(cmds[0].value, kPerfCyclesHGCmd); |
| EXPECT_TRUE(DoesCommandSampleCycles(cmds[0].value)); |
| EXPECT_EQ(cmds[1].value, kPerfFPCallgraphHGCmd); |
| EXPECT_TRUE(DoesCommandSampleCycles(cmds[1].value)); |
| EXPECT_FALSE( |
| base::Contains(cmds, kPerfLBRCmd, &RandomSelector::WeightAndValue::value)) |
| << "ARM64 does not support this command"; |
| EXPECT_FALSE(base::Contains(cmds, kPerfLLCMissesCmd, |
| &RandomSelector::WeightAndValue::value)) |
| << "ARM64 does not support this command"; |
| } |
| |
| TEST_F(PerfCollectorTest, DefaultCommandsBasedOnArch_Arm64_ETM) { |
| CPUIdentity cpuid; |
| cpuid.arch = "aarch64"; |
| cpuid.vendor = ""; |
| cpuid.family = 0; |
| cpuid.model = 0; |
| cpuid.model_name = ""; |
| std::vector<RandomSelector::WeightAndValue> cmds = |
| internal::GetDefaultCommandsForCpuModel(cpuid, "TROGDOR"); |
| ASSERT_GE(cmds.size(), 3UL); |
| EXPECT_EQ(cmds[0].value, kPerfCyclesHGCmd); |
| EXPECT_TRUE(DoesCommandSampleCycles(cmds[0].value)); |
| EXPECT_EQ(cmds[1].value, kPerfFPCallgraphHGCmd); |
| EXPECT_TRUE(DoesCommandSampleCycles(cmds[1].value)); |
| EXPECT_EQ(cmds[2].value, kPerfETMCmd); |
| EXPECT_TRUE(DoesCommandSampleETM(cmds[2].value)); |
| } |
| |
| TEST_F(PerfCollectorTest, DefaultCommandsBasedOnArch_x86_32) { |
| CPUIdentity cpuid; |
| cpuid.arch = "x86"; |
| cpuid.vendor = "GenuineIntel"; |
| cpuid.family = 0x06; |
| cpuid.model = 0x2f; // Westmere |
| cpuid.model_name = ""; |
| std::vector<RandomSelector::WeightAndValue> cmds = |
| internal::GetDefaultCommandsForCpuModel(cpuid, ""); |
| ASSERT_GE(cmds.size(), 2UL); |
| EXPECT_EQ(cmds[0].value, kPerfCyclesHGCmd); |
| EXPECT_TRUE(DoesCommandSampleCycles(cmds[0].value)); |
| EXPECT_EQ(cmds[1].value, kPerfFPCallgraphHGCmd); |
| EXPECT_TRUE(DoesCommandSampleCycles(cmds[1].value)); |
| EXPECT_FALSE( |
| base::Contains(cmds, kPerfLBRCmd, &RandomSelector::WeightAndValue::value)) |
| << "x86_32 does not support this command"; |
| EXPECT_FALSE(base::Contains(cmds, kPerfLLCMissesCmd, |
| &RandomSelector::WeightAndValue::value)) |
| << "x86_32 does not support this command"; |
| } |
| |
| TEST_F(PerfCollectorTest, DefaultCommandsBasedOnArch_Unknown) { |
| CPUIdentity cpuid; |
| cpuid.arch = "nonsense"; |
| cpuid.vendor = ""; |
| cpuid.family = 0; |
| cpuid.model = 0; |
| cpuid.model_name = ""; |
| std::vector<RandomSelector::WeightAndValue> cmds = |
| internal::GetDefaultCommandsForCpuModel(cpuid, ""); |
| EXPECT_EQ(1UL, cmds.size()); |
| EXPECT_EQ(cmds[0].value, kPerfCyclesHGCmd); |
| EXPECT_TRUE(DoesCommandSampleCycles(cmds[0].value)); |
| } |
| |
| TEST_F(PerfCollectorTest, CommandMatching_Empty) { |
| CPUIdentity cpuid = {}; |
| std::map<std::string, std::string> params; |
| EXPECT_EQ("", internal::FindBestCpuSpecifierFromParams(params, cpuid)); |
| } |
| |
| TEST_F(PerfCollectorTest, CommandMatching_NoPerfCommands) { |
| CPUIdentity cpuid = {}; |
| std::map<std::string, std::string> params; |
| params.insert(std::make_pair("NotEvenClose", "")); |
| params.insert(std::make_pair("NotAPerfCommand", "")); |
| params.insert(std::make_pair("NotAPerfCommand::Really", "")); |
| params.insert(std::make_pair("NotAPerfCommand::Nope::0", "")); |
| params.insert(std::make_pair("PerfCommands::SoClose::0", "")); |
| EXPECT_EQ("", internal::FindBestCpuSpecifierFromParams(params, cpuid)); |
| } |
| |
| TEST_F(PerfCollectorTest, CommandMatching_NoMatch) { |
| CPUIdentity cpuid; |
| cpuid.arch = "x86_64"; |
| cpuid.vendor = "GenuineIntel"; |
| cpuid.family = 6; |
| cpuid.model = 0x3a; // IvyBridge |
| cpuid.model_name = "Xeon or somesuch"; |
| std::map<std::string, std::string> params; |
| params.insert(std::make_pair("PerfCommand::armv7l::0", "perf command")); |
| params.insert(std::make_pair("PerfCommand::x86::0", "perf command")); |
| params.insert(std::make_pair("PerfCommand::x86::1", "perf command")); |
| params.insert(std::make_pair("PerfCommand::Broadwell::0", "perf command")); |
| |
| EXPECT_EQ("", internal::FindBestCpuSpecifierFromParams(params, cpuid)); |
| } |
| |
| TEST_F(PerfCollectorTest, CommandMatching_default) { |
| CPUIdentity cpuid; |
| cpuid.arch = "x86_64"; |
| cpuid.vendor = "GenuineIntel"; |
| cpuid.family = 6; |
| cpuid.model = 0x3a; // IvyBridge |
| cpuid.model_name = "Xeon or somesuch"; |
| std::map<std::string, std::string> params; |
| params.insert(std::make_pair("PerfCommand::default::0", "perf command")); |
| params.insert(std::make_pair("PerfCommand::armv7l::0", "perf command")); |
| params.insert(std::make_pair("PerfCommand::x86::0", "perf command")); |
| params.insert(std::make_pair("PerfCommand::x86::1", "perf command")); |
| params.insert(std::make_pair("PerfCommand::Broadwell::0", "perf command")); |
| |
| EXPECT_EQ("default", internal::FindBestCpuSpecifierFromParams(params, cpuid)); |
| } |
| |
| TEST_F(PerfCollectorTest, CommandMatching_SystemArch) { |
| CPUIdentity cpuid; |
| cpuid.arch = "nothing_in_particular"; |
| cpuid.vendor = ""; |
| cpuid.family = 0; |
| cpuid.model = 0; |
| cpuid.model_name = ""; |
| std::map<std::string, std::string> params; |
| params.insert(std::make_pair("PerfCommand::default::0", "perf command")); |
| params.insert(std::make_pair("PerfCommand::armv7l::0", "perf command")); |
| params.insert(std::make_pair("PerfCommand::x86::0", "perf command")); |
| params.insert(std::make_pair("PerfCommand::x86::1", "perf command")); |
| params.insert(std::make_pair("PerfCommand::x86_64::0", "perf command")); |
| params.insert(std::make_pair("PerfCommand::x86_64::xyz#$%", "perf command")); |
| params.insert(std::make_pair("PerfCommand::Broadwell::0", "perf command")); |
| |
| EXPECT_EQ("default", internal::FindBestCpuSpecifierFromParams(params, cpuid)); |
| |
| cpuid.arch = "armv7l"; |
| EXPECT_EQ("armv7l", internal::FindBestCpuSpecifierFromParams(params, cpuid)); |
| |
| cpuid.arch = "x86"; |
| EXPECT_EQ("x86", internal::FindBestCpuSpecifierFromParams(params, cpuid)); |
| |
| cpuid.arch = "x86_64"; |
| EXPECT_EQ("x86_64", internal::FindBestCpuSpecifierFromParams(params, cpuid)); |
| } |
| |
| TEST_F(PerfCollectorTest, CommandMatching_Microarchitecture) { |
| CPUIdentity cpuid; |
| cpuid.arch = "x86_64"; |
| cpuid.vendor = "GenuineIntel"; |
| cpuid.family = 6; |
| cpuid.model = 0x3D; // Broadwell |
| cpuid.model_name = "Wrong Model CPU @ 0 Hz"; |
| std::map<std::string, std::string> params; |
| params.insert(std::make_pair("PerfCommand::default::0", "perf command")); |
| params.insert(std::make_pair("PerfCommand::x86_64::0", "perf command")); |
| params.insert(std::make_pair("PerfCommand::Broadwell::0", "perf command")); |
| params.insert( |
| std::make_pair("PerfCommand::interesting-model-500x::0", "perf command")); |
| |
| EXPECT_EQ("Broadwell", |
| internal::FindBestCpuSpecifierFromParams(params, cpuid)); |
| } |
| |
| TEST_F(PerfCollectorTest, CommandMatching_SpecificModel) { |
| CPUIdentity cpuid; |
| cpuid.arch = "x86_64"; |
| cpuid.vendor = "GenuineIntel"; |
| cpuid.family = 6; |
| cpuid.model = 0x3D; // Broadwell |
| cpuid.model_name = "An Interesting(R) Model(R) 500x CPU @ 1.2GHz"; |
| std::map<std::string, std::string> params; |
| params.insert(std::make_pair("PerfCommand::default::0", "perf command")); |
| params.insert(std::make_pair("PerfCommand::x86_64::0", "perf command")); |
| params.insert(std::make_pair("PerfCommand::Broadwell::0", "perf command")); |
| params.insert( |
| std::make_pair("PerfCommand::interesting-model-500x::0", "perf command")); |
| |
| EXPECT_EQ("interesting-model-500x", |
| internal::FindBestCpuSpecifierFromParams(params, cpuid)); |
| } |
| |
| TEST_F(PerfCollectorTest, CommandMatching_SpecificModel_LongestMatch) { |
| CPUIdentity cpuid; |
| cpuid.arch = "x86_64"; |
| cpuid.vendor = "GenuineIntel"; |
| cpuid.family = 6; |
| cpuid.model = 0x3D; // Broadwell |
| cpuid.model_name = "An Interesting(R) Model(R) 500x CPU @ 1.2GHz"; |
| std::map<std::string, std::string> params; |
| params.insert(std::make_pair("PerfCommand::default::0", "perf command")); |
| params.insert(std::make_pair("PerfCommand::x86_64::0", "perf command")); |
| params.insert(std::make_pair("PerfCommand::Broadwell::0", "perf command")); |
| params.insert(std::make_pair("PerfCommand::model-500x::0", "perf command")); |
| params.insert( |
| std::make_pair("PerfCommand::interesting-model-500x::0", "perf command")); |
| params.insert( |
| std::make_pair("PerfCommand::interesting-model::0", "perf command")); |
| |
| EXPECT_EQ("interesting-model-500x", |
| internal::FindBestCpuSpecifierFromParams(params, cpuid)); |
| } |
| |
| // Testing that jankiness collection trigger doesn't interfere with an ongoing |
| // collection. |
| TEST_F(PerfCollectorTest, StopCollection_AnotherTrigger) { |
| const int kRestoredTabs = 1; |
| |
| perf_collector_->CollectPerfDataAfterSessionRestore(base::Seconds(1), |
| kRestoredTabs); |
| // Timer is active after the OnSessionRestoreDone call. |
| EXPECT_TRUE(perf_collector_->IsRunning()); |
| // A collection in action: should reject another collection request. |
| EXPECT_FALSE(perf_collector_->ShouldCollect()); |
| |
| task_environment_.FastForwardBy(base::Milliseconds(100)); |
| // A collection is ongoing. Triggering a jankiness collection should have no |
| // effect on the existing collection. |
| perf_collector_->OnJankStarted(); |
| task_environment_.FastForwardBy(base::Milliseconds(100)); |
| // This doesn't stop the existing collection. |
| perf_collector_->OnJankStopped(); |
| task_environment_.RunUntilIdle(); |
| EXPECT_FALSE(perf_collector_->collection_done()); |
| EXPECT_FALSE(perf_collector_->collection_stopped()); |
| |
| // Fast forward time past the collection duration to complete the collection. |
| task_environment_.FastForwardBy( |
| perf_collector_->collection_params().collection_duration); |
| // The collection finishes automatically without being stopped. |
| EXPECT_FALSE(perf_collector_->collection_stopped()); |
| EXPECT_TRUE(perf_collector_->collection_done()); |
| |
| ASSERT_EQ(1U, cached_profile_data_.size()); |
| |
| // Timer is rearmed for periodic collection after each collection. |
| EXPECT_TRUE(perf_collector_->IsRunning()); |
| |
| const SampledProfile& profile = cached_profile_data_[0]; |
| EXPECT_EQ(SampledProfile::RESTORE_SESSION, profile.trigger_event()); |
| EXPECT_EQ(kRestoredTabs, profile.num_tabs_restored()); |
| EXPECT_FALSE(profile.has_ms_after_resume()); |
| EXPECT_TRUE(profile.has_ms_after_login()); |
| EXPECT_TRUE(profile.has_ms_after_boot()); |
| } |
| |
| // Test stopping a jankiness collection. |
| TEST_F(PerfCollectorTest, JankinessCollectionStopped) { |
| EXPECT_TRUE(perf_collector_->ShouldCollect()); |
| perf_collector_->OnJankStarted(); |
| // A collection in action: should reject another collection request. |
| EXPECT_FALSE(perf_collector_->ShouldCollect()); |
| |
| task_environment_.FastForwardBy(base::Milliseconds(100)); |
| |
| perf_collector_->OnJankStopped(); |
| task_environment_.RunUntilIdle(); |
| EXPECT_TRUE(perf_collector_->collection_done()); |
| EXPECT_TRUE(perf_collector_->collection_stopped()); |
| |
| ASSERT_EQ(1U, cached_profile_data_.size()); |
| |
| // Timer is rearmed for periodic collection after each collection. |
| EXPECT_TRUE(perf_collector_->IsRunning()); |
| |
| const SampledProfile& profile = cached_profile_data_[0]; |
| EXPECT_EQ(SampledProfile::JANKY_TASK, profile.trigger_event()); |
| EXPECT_FALSE(profile.has_ms_after_resume()); |
| EXPECT_TRUE(profile.has_ms_after_login()); |
| EXPECT_TRUE(profile.has_ms_after_boot()); |
| } |
| |
| // Test a jankiness collection is done when the collection duration elapses. |
| TEST_F(PerfCollectorTest, JankinessCollectionDurationElapsed) { |
| EXPECT_TRUE(perf_collector_->ShouldCollect()); |
| perf_collector_->OnJankStarted(); |
| // A collection in action: should reject another collection request. |
| EXPECT_FALSE(perf_collector_->ShouldCollect()); |
| |
| // The jank lasts for 2 collection durations. The collection should be done |
| // before the jank stops. |
| task_environment_.FastForwardBy( |
| 2 * perf_collector_->collection_params().collection_duration); |
| // The collection is done without being stopped. |
| EXPECT_TRUE(perf_collector_->collection_done()); |
| EXPECT_FALSE(perf_collector_->collection_stopped()); |
| |
| ASSERT_EQ(1U, cached_profile_data_.size()); |
| |
| // Timer is rearmed for periodic collection after each collection. |
| EXPECT_TRUE(perf_collector_->IsRunning()); |
| |
| const SampledProfile& profile = cached_profile_data_[0]; |
| EXPECT_EQ(SampledProfile::JANKY_TASK, profile.trigger_event()); |
| EXPECT_FALSE(profile.has_ms_after_resume()); |
| EXPECT_TRUE(profile.has_ms_after_login()); |
| EXPECT_TRUE(profile.has_ms_after_boot()); |
| |
| perf_collector_->OnJankStopped(); |
| task_environment_.RunUntilIdle(); |
| // The arrival of OnJankStopped() has no effect on PerfCollector after the |
| // collection is done. |
| EXPECT_TRUE(perf_collector_->collection_done()); |
| EXPECT_FALSE(perf_collector_->collection_stopped()); |
| } |
| |
| TEST_F(PerfCollectorTest, LacrosPathRootfs) { |
| base::HistogramTester histogram_tester; |
| const char rootfs_path[] = "/run/lacros/chrome"; |
| metrics::SystemProfileProto_Channel rootfs_lacros_channel; |
| std::string rootfs_lacros_version; |
| EXPECT_FALSE(TestPerfCollector::LacrosChannelAndVersion( |
| rootfs_path, rootfs_lacros_channel, rootfs_lacros_version)); |
| histogram_tester.ExpectUniqueSample( |
| "ChromeOS.CWP.ParseLacrosPath", |
| TestPerfCollector::ParseLacrosPath::kRootfs, 1); |
| } |
| |
| TEST_F(PerfCollectorTest, LacrosChannelAndVersion) { |
| base::HistogramTester histogram_tester; |
| |
| const char stable_path[] = |
| "/run/imageloader/lacros-dogfood-stable/95.0.4623.2/chrome"; |
| metrics::SystemProfileProto_Channel stable_channel; |
| std::string stable_version; |
| EXPECT_TRUE(TestPerfCollector::LacrosChannelAndVersion( |
| stable_path, stable_channel, stable_version)); |
| EXPECT_EQ(stable_channel, metrics::SystemProfileProto_Channel_CHANNEL_STABLE); |
| EXPECT_EQ(stable_version, "95.0.4623.2"); |
| |
| const char beta_path[] = |
| "/run/imageloader/lacros-dogfood-beta/97.0.4623.2/chrome"; |
| metrics::SystemProfileProto_Channel beta_channel; |
| std::string beta_version; |
| EXPECT_TRUE(TestPerfCollector::LacrosChannelAndVersion( |
| beta_path, beta_channel, beta_version)); |
| EXPECT_EQ(beta_channel, metrics::SystemProfileProto_Channel_CHANNEL_BETA); |
| EXPECT_EQ(beta_version, "97.0.4623.2"); |
| |
| const char dev_path[] = |
| "/run/imageloader/lacros-dogfood-dev/99.0.4623.2/chrome"; |
| metrics::SystemProfileProto_Channel dev_channel; |
| std::string dev_version; |
| EXPECT_TRUE(TestPerfCollector::LacrosChannelAndVersion(dev_path, dev_channel, |
| dev_version)); |
| EXPECT_EQ(dev_channel, metrics::SystemProfileProto_Channel_CHANNEL_DEV); |
| EXPECT_EQ(dev_version, "99.0.4623.2"); |
| |
| const char canary_path[] = |
| "/run/imageloader/lacros-dogfood-canary/100.0.4623.2/chrome"; |
| metrics::SystemProfileProto_Channel canary_channel; |
| std::string canary_version; |
| EXPECT_TRUE(TestPerfCollector::LacrosChannelAndVersion( |
| canary_path, canary_channel, canary_version)); |
| EXPECT_EQ(canary_channel, metrics::SystemProfileProto_Channel_CHANNEL_CANARY); |
| EXPECT_EQ(canary_version, "100.0.4623.2"); |
| |
| histogram_tester.ExpectUniqueSample( |
| "ChromeOS.CWP.ParseLacrosPath", |
| TestPerfCollector::ParseLacrosPath::kStateful, 4); |
| } |
| |
| TEST_F(PerfCollectorTest, LacrosPathUnrecognized) { |
| base::HistogramTester histogram_tester; |
| const char unrecognized_path[] = "/run/imageloader/lacros/chrome"; |
| metrics::SystemProfileProto_Channel unrecognized_channel; |
| std::string unrecognized_version; |
| EXPECT_FALSE(TestPerfCollector::LacrosChannelAndVersion( |
| unrecognized_path, unrecognized_channel, unrecognized_version)); |
| histogram_tester.ExpectUniqueSample( |
| "ChromeOS.CWP.ParseLacrosPath", |
| TestPerfCollector::ParseLacrosPath::kUnrecognized, 1); |
| } |
| |
| TEST_F(PerfCollectorTest, CommandEventType) { |
| using EventType = TestPerfCollector::EventType; |
| EXPECT_EQ(TestPerfCollector::CommandEventType({"--duration", "0", "--", |
| "record", "-a", "-e", "cycles", |
| "-c", "1000003"}), |
| EventType::kCycles); |
| EXPECT_EQ(TestPerfCollector::CommandEventType({"--duration", "0", "--", |
| "record", "-a", "-e", "cycles", |
| "-g", "-c", "4000037"}), |
| EventType::kCycles); |
| EXPECT_EQ(TestPerfCollector::CommandEventType( |
| {"--duration", "0", "--", "record", "-a", "-e", "cycles", "-c", |
| "4000037", "--call-graph", "lbr"}), |
| EventType::kCycles); |
| EXPECT_EQ(TestPerfCollector::CommandEventType( |
| {"--duration", "0", "--", "record", "-a", "-e", "cycles:ppp", |
| "-c", "1000003"}), |
| EventType::kCycles); |
| EXPECT_EQ(TestPerfCollector::CommandEventType( |
| {"--duration", "0", "--", "record", "-a", "-e", "cycles:ppp", |
| "-g", "-c", "4000037"}), |
| EventType::kCycles); |
| EXPECT_EQ(TestPerfCollector::CommandEventType( |
| {"--duration", "0", "--", "record", "-a", "-e", "cycles:ppp", |
| "-c", "4000037", "--call-graph", "lbr"}), |
| EventType::kCycles); |
| |
| EXPECT_EQ(TestPerfCollector::CommandEventType({"--duration", "0", "--", |
| "record", "-a", "-e", "r20c4", |
| "-b", "-c", "200011"}), |
| EventType::kOther); |
| EXPECT_EQ(TestPerfCollector::CommandEventType({"--duration", "0", "--", |
| "record", "-a", "-e", "rc4", |
| "-b", "-c", "300001"}), |
| EventType::kOther); |
| EXPECT_EQ( |
| TestPerfCollector::CommandEventType({"--duration", "0", "--", "record", |
| "-a", "-e", "r0481", "-c", "2003"}), |
| EventType::kOther); |
| EXPECT_EQ( |
| TestPerfCollector::CommandEventType({"--duration", "0", "--", "record", |
| "-a", "-e", "r13d0", "-c", "2003"}), |
| EventType::kOther); |
| EXPECT_EQ(TestPerfCollector::CommandEventType({"--duration", "0", "--", |
| "record", "-a", "-e", |
| "iTLB-misses", "-c", "2003"}), |
| EventType::kOther); |
| EXPECT_EQ(TestPerfCollector::CommandEventType({"--duration", "0", "--", |
| "record", "-a", "-e", |
| "dTLB-misses", "-c", "2003"}), |
| EventType::kOther); |
| EXPECT_EQ(TestPerfCollector::CommandEventType( |
| {"--duration", "0", "--", "record", "-a", "-e", "cache-misses", |
| "-c", "10007"}), |
| EventType::kOther); |
| |
| EXPECT_EQ(TestPerfCollector::CommandEventType( |
| {"--duration", "0", "--", "record", "-a", "-e", "instructions", |
| "-e", "cycles", "-c", "1000003"}), |
| EventType::kCycles); |
| EXPECT_EQ(TestPerfCollector::CommandEventType( |
| {"--duration", "0", "--", "record", "-a", "-e", "instructions", |
| "-e", "cycles:ppp", "-c", "1000003"}), |
| EventType::kCycles); |
| |
| EXPECT_EQ(TestPerfCollector::CommandEventType({"--duration", "0", "--", |
| "stat", "-a", "-e", "cycles", |
| "-e", "instructions"}), |
| EventType::kOther); |
| |
| EXPECT_EQ( |
| TestPerfCollector::CommandEventType( |
| {"--duration", "0", "--", "record", "-e", "cs_etm/autofdo/", "-a"}), |
| EventType::kETM); |
| EXPECT_EQ( |
| TestPerfCollector::CommandEventType( |
| {"--duration", "0", "--", "record", "-e", "cs_etm/autofdo/u", "-a"}), |
| EventType::kETM); |
| EXPECT_EQ(TestPerfCollector::CommandEventType( |
| {"--duration", "0", "--", "record", "-e", |
| "cs_etm/autofdo,preset=1/", "-a"}), |
| EventType::kETM); |
| EXPECT_EQ(TestPerfCollector::CommandEventType( |
| {"--duration", "0", "--run_inject", "--inject_args", "-b", "--", |
| "record", "-e", "cs_etm/autofdo/", "-a"}), |
| EventType::kETM); |
| } |
| |
| class PerfCollectorCollectionParamsTest : public testing::Test { |
| public: |
| PerfCollectorCollectionParamsTest() = default; |
| |
| PerfCollectorCollectionParamsTest(const PerfCollectorCollectionParamsTest&) = |
| delete; |
| PerfCollectorCollectionParamsTest& operator=( |
| const PerfCollectorCollectionParamsTest&) = delete; |
| |
| void TearDown() override { |
| variations::testing::ClearAllVariationParams(); |
| } |
| |
| protected: |
| content::BrowserTaskEnvironment task_environment_; |
| }; |
| |
| TEST_F(PerfCollectorCollectionParamsTest, Commands_InitializedAfterVariations) { |
| auto perf_collector = std::make_unique<TestPerfCollector>(); |
| EXPECT_TRUE(perf_collector->command_selector().odds().empty()); |
| // Init would be called after VariationsService is initialized. |
| perf_collector->Init(); |
| EXPECT_FALSE(perf_collector->command_selector().odds().empty()); |
| } |
| |
| TEST_F(PerfCollectorCollectionParamsTest, Commands_EmptyExperiment) { |
| std::vector<RandomSelector::WeightAndValue> default_cmds = |
| internal::GetDefaultCommandsForCpuModel( |
| GetCPUIdentity(), base::SysInfo::HardwareModelName()); |
| std::map<std::string, std::string> params; |
| ASSERT_TRUE(base::AssociateFieldTrialParams("ChromeOSWideProfilingCollection", |
| "group_name", params)); |
| ASSERT_TRUE(base::FieldTrialList::CreateFieldTrial( |
| "ChromeOSWideProfilingCollection", "group_name")); |
| |
| auto perf_collector = std::make_unique<TestPerfCollector>(); |
| EXPECT_TRUE(perf_collector->command_selector().odds().empty()); |
| perf_collector->Init(); |
| EXPECT_EQ(default_cmds, perf_collector->command_selector().odds()); |
| } |
| |
| TEST_F(PerfCollectorCollectionParamsTest, Commands_InvalidValues) { |
| std::vector<RandomSelector::WeightAndValue> default_cmds = |
| internal::GetDefaultCommandsForCpuModel( |
| GetCPUIdentity(), base::SysInfo::HardwareModelName()); |
| std::map<std::string, std::string> params; |
| // Use the "default" cpu specifier since we don't want to predict what CPU |
| // this test is running on. (CPU detection is tested above.) |
| params.insert(std::make_pair("PerfCommand::default::0", "")); |
| params.insert(std::make_pair("PerfCommand::default::1", " ")); |
| params.insert(std::make_pair("PerfCommand::default::2", " leading space")); |
| params.insert( |
| std::make_pair("PerfCommand::default::3", "no-spaces-or-numbers")); |
| params.insert( |
| std::make_pair("PerfCommand::default::4", "NaN-trailing-space ")); |
| params.insert(std::make_pair("PerfCommand::default::5", "NaN x")); |
| params.insert(std::make_pair("PerfCommand::default::6", "perf command")); |
| ASSERT_TRUE(base::AssociateFieldTrialParams("ChromeOSWideProfilingCollection", |
| "group_name", params)); |
| ASSERT_TRUE(base::FieldTrialList::CreateFieldTrial( |
| "ChromeOSWideProfilingCollection", "group_name")); |
| |
| auto perf_collector = std::make_unique<TestPerfCollector>(); |
| EXPECT_TRUE(perf_collector->command_selector().odds().empty()); |
| perf_collector->Init(); |
| EXPECT_EQ(default_cmds, perf_collector->command_selector().odds()); |
| } |
| |
| TEST_F(PerfCollectorCollectionParamsTest, Commands_Override) { |
| using WeightAndValue = RandomSelector::WeightAndValue; |
| std::vector<RandomSelector::WeightAndValue> default_cmds = |
| internal::GetDefaultCommandsForCpuModel( |
| GetCPUIdentity(), base::SysInfo::HardwareModelName()); |
| std::map<std::string, std::string> params; |
| // Use the "default" cpu specifier since we don't want to predict what CPU |
| // this test is running on. (CPU detection is tested above.) |
| params.insert( |
| std::make_pair("PerfCommand::default::0", "50 perf record foo")); |
| params.insert( |
| std::make_pair("PerfCommand::default::1", "25 perf record bar")); |
| params.insert( |
| std::make_pair("PerfCommand::default::2", "25 perf record baz")); |
| params.insert( |
| std::make_pair("PerfCommand::another-cpu::0", "7 perf record bar")); |
| ASSERT_TRUE(base::AssociateFieldTrialParams("ChromeOSWideProfilingCollection", |
| "group_name", params)); |
| ASSERT_TRUE(base::FieldTrialList::CreateFieldTrial( |
| "ChromeOSWideProfilingCollection", "group_name")); |
| |
| auto perf_collector = std::make_unique<TestPerfCollector>(); |
| EXPECT_TRUE(perf_collector->command_selector().odds().empty()); |
| perf_collector->Init(); |
| |
| std::vector<WeightAndValue> expected_cmds; |
| expected_cmds.push_back(WeightAndValue(50.0, "perf record foo")); |
| expected_cmds.push_back(WeightAndValue(25.0, "perf record bar")); |
| expected_cmds.push_back(WeightAndValue(25.0, "perf record baz")); |
| |
| EXPECT_EQ(expected_cmds, perf_collector->command_selector().odds()); |
| } |
| |
| TEST_F(PerfCollectorCollectionParamsTest, Parameters_Override) { |
| std::map<std::string, std::string> params; |
| params.insert(std::make_pair("ProfileCollectionDurationSec", "15")); |
| params.insert(std::make_pair("PeriodicProfilingIntervalMs", "3600000")); |
| params.insert(std::make_pair("ResumeFromSuspend::SamplingFactor", "1")); |
| params.insert(std::make_pair("ResumeFromSuspend::MaxDelaySec", "10")); |
| params.insert(std::make_pair("RestoreSession::SamplingFactor", "2")); |
| params.insert(std::make_pair("RestoreSession::MaxDelaySec", "20")); |
| ASSERT_TRUE(base::AssociateFieldTrialParams("ChromeOSWideProfilingCollection", |
| "group_name", params)); |
| ASSERT_TRUE(base::FieldTrialList::CreateFieldTrial( |
| "ChromeOSWideProfilingCollection", "group_name")); |
| |
| auto perf_collector = std::make_unique<TestPerfCollector>(); |
| const auto& parsed_params = perf_collector->collection_params(); |
| |
| // Not initialized yet: |
| EXPECT_NE(base::Seconds(15), parsed_params.collection_duration); |
| EXPECT_NE(base::Hours(1), parsed_params.periodic_interval); |
| EXPECT_NE(1, parsed_params.resume_from_suspend.sampling_factor); |
| EXPECT_NE(base::Seconds(10), |
| parsed_params.resume_from_suspend.max_collection_delay); |
| EXPECT_NE(2, parsed_params.restore_session.sampling_factor); |
| EXPECT_NE(base::Seconds(20), |
| parsed_params.restore_session.max_collection_delay); |
| |
| perf_collector->Init(); |
| |
| EXPECT_EQ(base::Seconds(15), parsed_params.collection_duration); |
| EXPECT_EQ(base::Hours(1), parsed_params.periodic_interval); |
| EXPECT_EQ(1, parsed_params.resume_from_suspend.sampling_factor); |
| EXPECT_EQ(base::Seconds(10), |
| parsed_params.resume_from_suspend.max_collection_delay); |
| EXPECT_EQ(2, parsed_params.restore_session.sampling_factor); |
| EXPECT_EQ(base::Seconds(20), |
| parsed_params.restore_session.max_collection_delay); |
| } |
| |
| } // namespace metrics |
