Add BytesRead metric to CPM

chrome/browser/performance_monitor/performance_monitor.cc

 // Copyright (c) 2012 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/browser/performance_monitor/performance_monitor.h"
 
 #include <set>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 16 matching lines @@
 #include "chrome/common/chrome_version_info.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/test/base/chrome_process_util.h"
 #include "content/public/browser/browser_child_process_host.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/load_notification_details.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/web_contents.h"
+#include "net/url_request/url_request.h"
 
 using content::BrowserThread;
 using extensions::Extension;
 
 namespace {
 const uint32 kAccessFlags = base::kProcessAccessDuplicateHandle |
                             base::kProcessAccessQueryInformation |
                             base::kProcessAccessTerminate |
                             base::kProcessAccessWaitForTermination;
 
 std::string TimeToString(base::Time time) {
   int64 time_int64 = time.ToInternalValue();
   return base::Int64ToString(time_int64);
 }
 
 bool StringToTime(std::string time, base::Time* output) {
   int64 time_int64 = 0;
   if (!base::StringToInt64(time, &time_int64))
     return false;
   *output = base::Time::FromInternalValue(time_int64);
   return true;
 }
 
 }  // namespace
 
 namespace performance_monitor {
 
+bool PerformanceMonitor::initialized_ = false;
+
+PerformanceMonitor::PerformanceDataForIOThread::PerformanceDataForIOThread()
+    : network_bytes_read(0) {
+}
+
 PerformanceMonitor::PerformanceMonitor() : database_(NULL) {
 }
 
 PerformanceMonitor::~PerformanceMonitor() {
 }
 
 bool PerformanceMonitor::SetDatabasePath(const FilePath& path) {
   if (!database_.get()) {
     database_path_ = path;
     return true;
@@ skipping 13 matching lines @@
       FROM_HERE,
       base::Bind(&PerformanceMonitor::InitOnBackgroundThread,
                  base::Unretained(this)),
       base::Bind(&PerformanceMonitor::FinishInit,
                  base::Unretained(this)));
 }
 
 void PerformanceMonitor::InitOnBackgroundThread() {
   CHECK(!BrowserThread::CurrentlyOn(BrowserThread::UI));
   database_ = Database::Create(database_path_);
+
+  // Initialize the io thread's performance data to the value in the database;
+  // if there isn't a recording in the database, the value stays at 0.
+  MetricInfo info;
+  if (database_->GetRecentStatsForActivityAndMetric(METRIC_NETWORK_BYTES_READ,
+                                                    &info)) {
+    performance_data_for_io_thread_.network_bytes_read = info.value;

[battre, 2012/08/22 19:23:02]

you access the variable on the UI thread. Sorry that I did not notice this
earlier.

[Devlin, 2012/08/22 20:34:55]

Well, I've been wrong on threading every step of the way here, but I still
*think* this one's okay (I look forward to the reason I'm wrong!) :)

This happens (only) during the initialization of PerformanceMonitor, which is,
in itself, synchronous (it has thread jumping, but it does so synchronously).
Only at the *end* of the initialization is the initialized_ flag set to true.
OnRawBytesRead() checks this initialized flag to make sure that
PerformanceMonitor is initialized before calling BytesReadOnIOThread(). Thus, we
only call BytesReadOnIOThread() if we have conclusively already done the access
on this thread.

initialized_ isn't a thread-safety concern because it is a boolean - it is
either on or off. If it is even partially on , then the instruction was reached
and it is, in effect, fully on. Otherwise it is off, and should be off.

[battre, 2012/08/22 20:50:24]

Maybe you can move the check whether initialzed_ is true to
BytesReadOnIOThread(). That way the access is thread safe by the API of the
class and does not depend on correct calling conventions.

[Devlin, 2012/08/23 16:41:02]

Done.

+  }
 }
 
 void PerformanceMonitor::FinishInit() {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   RegisterForNotifications();
   CheckForUncleanExits();
   BrowserThread::PostBlockingPoolSequencedTask(
       Database::kDatabaseSequenceToken,
       FROM_HERE,
       base::Bind(&PerformanceMonitor::CheckForVersionUpdateOnBackgroundThread,
@@ skipping 130 matching lines @@
                                                      const std::string& value) {
   DCHECK(!BrowserThread::CurrentlyOn(BrowserThread::UI));
   database_->AddMetric(type, value);
 }
 
 void PerformanceMonitor::NotifyInitialized() {
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_PERFORMANCE_MONITOR_INITIALIZED,
       content::Source<PerformanceMonitor>(this),
       content::NotificationService::NoDetails());
+
+  initialized_ = true;
 }
 
 void PerformanceMonitor::GatherStatisticsOnBackgroundThread() {
   CHECK(!BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // Because the CPU usage is gathered as an average since the last time the
   // function was called, while the memory usage is gathered as an instantaneous
   // usage, the CPU usage is gathered before the metrics map is wiped.
   GatherCPUUsageOnBackgroundThread();
   UpdateMetricsMapOnBackgroundThread();
@@ skipping 98 matching lines @@
   CHECK(!BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   for (std::set<std::string>::const_iterator iter = active_profiles->begin();
        iter != active_profiles->end(); ++iter) {
     database_->AddStateValue(kStateProfilePrefix + *iter, time);
   }
 }
 
 void PerformanceMonitor::DoTimedCollections() {
   UpdateLiveProfiles();
+
+  BrowserThread::PostBlockingPoolSequencedTask(
+      Database::kDatabaseSequenceToken,
+      FROM_HERE,
+      base::Bind(&PerformanceMonitor::GatherStatisticsOnBackgroundThread,
+                 base::Unretained(this)));
+
+  BrowserThread::PostTask(
+      BrowserThread::IO,
+      FROM_HERE,
+      base::Bind(&PerformanceMonitor::CallInsertIOData,
+                 base::Unretained(this)));
+}
+
+void PerformanceMonitor::CallInsertIOData() {
+  CHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+  BrowserThread::PostBlockingPoolSequencedTask(
+      Database::kDatabaseSequenceToken,
+      FROM_HERE,
+      base::Bind(&PerformanceMonitor::InsertIOData,
+                 base::Unretained(this),
+                 performance_data_for_io_thread_));
+}
+
+void PerformanceMonitor::InsertIOData(
+    PerformanceDataForIOThread performance_data_for_io_thread) {
+  CHECK(!BrowserThread::CurrentlyOn(BrowserThread::UI));
+  database_->AddMetric(
+      METRIC_NETWORK_BYTES_READ,
+      base::Uint64ToString(performance_data_for_io_thread.network_bytes_read));
+}
+
+void PerformanceMonitor::BytesReadOnIOThread(const net::URLRequest& request,
+                                             const int bytes_read) {
+  CHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+  if (!request.url().SchemeIsFile())
+    performance_data_for_io_thread_.network_bytes_read += bytes_read;
 }
 
 void PerformanceMonitor::Observe(int type,
                                  const content::NotificationSource& source,
                                  const content::NotificationDetails& details) {
   switch (type) {
     case chrome::NOTIFICATION_EXTENSION_INSTALLED: {
       AddExtensionEvent(EVENT_EXTENSION_INSTALL,
                         content::Details<Extension>(details).ptr());
       break;
@@ skipping 103 matching lines @@
 
   // Determine the type of crash.
   EventType type =
       details.status == base::TERMINATION_STATUS_PROCESS_WAS_KILLED ?
       EVENT_KILLED_BY_OS_CRASH : EVENT_RENDERER_CRASH;
 
   AddEvent(util::CreateCrashEvent(base::Time::Now(), type));
 }
 
 }  // namespace performance_monitor