Performance monitor stats gathering.

chrome/browser/performance_monitor/performance_monitor_browsertest.cc

 // Copyright (c) 2010 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/test/base/in_process_browser_test.h"
 
 #include "base/file_path.h"
 #include "base/logging.h"
 #include "base/path_service.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "chrome/browser/performance_monitor/constants.h"
 #include "chrome/browser/performance_monitor/database.h"
 #include "chrome/browser/performance_monitor/performance_monitor.h"
 #include "chrome/browser/extensions/extension_browsertest.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/unpacked_installer.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
+#include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_version_info.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/notification_service.h"
 
 using extensions::Extension;
 using performance_monitor::Event;
@@ skipping 104 matching lines @@
         Database::kDatabaseSequenceToken,
         FROM_HERE,
         base::Bind(&PerformanceMonitorBrowserTest::GetEventsOnBackgroundThread,
                    base::Unretained(this),
                    &events));
 
     content::BrowserThread::GetBlockingPool()->FlushForTesting();
     return events;
   }
 
+  void GetStatsForActivityAndMetricOnBackgroundThread(
+      const std::string& activity,
+      const std::string& metric,
+      Database::MetricInfoVector* stats) {
+    *stats = performance_monitor_->database()->
+        GetStatsForActivityAndMetric(activity, metric);
+  }
+
+  Database::MetricInfoVector GetStatsForActivityAndMetric(
+      const std::string& activity,
+      const std::string& metric) {
+    Database::MetricInfoVector stats;
+    content::BrowserThread::PostBlockingPoolSequencedTask(
+        Database::kDatabaseSequenceToken,
+        FROM_HERE,
+        base::Bind(&PerformanceMonitorBrowserTest::
+                       GetStatsForActivityAndMetricOnBackgroundThread,
+                   base::Unretained(this),
+                   activity,
+                   metric,
+                   &stats));
+
+    content::BrowserThread::GetBlockingPool()->FlushForTesting();
+    return stats;
+  }
+
   PerformanceMonitor* performance_monitor() const {
     return performance_monitor_;
   }
 
  protected:
   ScopedTempDir db_dir_;
   PerformanceMonitor* performance_monitor_;
 };
 
 // Test that PerformanceMonitor will correctly record an extension installation
@@ skipping 162 matching lines @@
 
   std::string previous_version;
   std::string current_version;
 
   ASSERT_TRUE(value->GetString("previous_version", &previous_version));
   ASSERT_EQ(kOldVersion, previous_version);
   ASSERT_TRUE(value->GetString("current_version", &current_version));
   ASSERT_EQ(version_string, current_version);
 }
 
+IN_PROC_BROWSER_TEST_F(PerformanceMonitorBrowserTest, GatherStatistics) {
+  content::BrowserThread::PostBlockingPoolSequencedTask(
+      Database::kDatabaseSequenceToken,
+      FROM_HERE,
+      base::Bind(&PerformanceMonitor::GatherStatistics,
+                 base::Unretained(performance_monitor())));
+
+  content::BrowserThread::GetBlockingPool()->FlushForTesting();
+
+  // CPU Usage -- no stats recorded the first time
+  Database::MetricInfoVector stats = GetStatsForActivityAndMetric(
+      performance_monitor::kProcessChromeAggregate,
+      performance_monitor::kMetricCPUUsage);
+  ASSERT_EQ(0u, stats.size());
+
+  // Private memory usage
+  stats = GetStatsForActivityAndMetric(
+      performance_monitor::kProcessChromeAggregate,
+      performance_monitor::kMetricPrivateMemoryUsage);
+  ASSERT_EQ(1u, stats.size());
+  LOG(INFO) << "Private memory usage median: " << stats[0].value;
+
+  // Shared memory usage
+  stats = GetStatsForActivityAndMetric(
+      performance_monitor::kProcessChromeAggregate,
+      performance_monitor::kMetricSharedMemoryUsage);
+  ASSERT_EQ(1u, stats.size());
+  LOG(INFO) << "Shared memory usage median: " << stats[0].value;
+
+  // TODO(mwrosen) something less barbaric?
+  // Spin for a while, so CPU usage isn't 0

[Yoyo Zhou, 2012/07/09 21:33:36]

Why is this necessary? Could CPU usage be 0 in the real world?

[mitchellwrosen, 2012/07/09 22:45:23]

Yeah, the CPU usage could be zero in the real world. I was trying to force the
process to consume a noticeable amount of cycles just to test that GetCPUUsage
is working properly. It's a rubbish test, I agree. Do you have any other
suggestions?

[Yoyo Zhou, 2012/07/10 21:58:00]

Well, the LOG(INFO) also suggests that these are tests that have to be looked at
by a human. When these tests are run by the bots, then, you should expect that
only assertion failures will be looked at.

Remember that you're testing your system, not necessarily the low-level
components it's built on. (Although I don't see tests for GetCPUUsage and such,
presumably because they're hard to test.)

I don't know what to suggest, but here are some thoughts:
- Change the LOG(INFO) to a DVLOG(1) or some such, so that it doesn't spam the
test logs. You would have to run it yourself with a debug build and
--vmodule=performance_monitor_browsertest=1 to see the messages though.
- Ensure that the CPU spinning doesn't slow down the bots running tests too
much.
- If it's possible, check that the medians you compute are actually medians.

+  for (int i = 0; i < 1000000000; ++i) {

[Yoyo Zhou, 2012/07/09 21:33:36]

I'd be careful with something like this... a compiler could perhaps even
optimize it out. Perhaps i could be moved to function scope, and then
ASSERT_EQ(100000000000, i).

[mitchellwrosen, 2012/07/09 22:45:23]

Done.

+  }
+
+  content::BrowserThread::PostBlockingPoolSequencedTask(
+      Database::kDatabaseSequenceToken,
+      FROM_HERE,
+      base::Bind(&PerformanceMonitor::GatherStatistics,
+                 base::Unretained(performance_monitor())));
+
+  content::BrowserThread::GetBlockingPool()->FlushForTesting();
+
+  stats = GetStatsForActivityAndMetric(
+      performance_monitor::kProcessChromeAggregate,
+      performance_monitor::kMetricCPUUsage);
+  ASSERT_EQ(1u, stats.size());
+  EXPECT_GT(stats[0].value, 0);
+  LOG(INFO) << "CPU usage median: " << stats[0].value;
+
+  // Private memory usage #2
+  stats = GetStatsForActivityAndMetric(
+      performance_monitor::kProcessChromeAggregate,
+      performance_monitor::kMetricPrivateMemoryUsage);
+  ASSERT_EQ(2u, stats.size());
+  LOG(INFO) << "Private memory usage median #2: " << stats[1].value;
+
+  // Shared memory usage #2
+  stats = GetStatsForActivityAndMetric(
+      performance_monitor::kProcessChromeAggregate,
+      performance_monitor::kMetricSharedMemoryUsage);
+  ASSERT_EQ(2u, stats.size());
+  LOG(INFO) << "Shared memory usage median #2: " << stats[1].value;
+}
+
 }  // namespace performance_monitor