[tracing] Add memory statistics from level db clients to tracing.

content/browser/dom_storage/session_storage_database.cc

 // Copyright 2013 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 "content/browser/dom_storage/session_storage_database.h"
 
 #include <vector>
 
 #include "base/files/file_util.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
+#include "base/thread_task_runner_handle.h"
+#include "base/trace_event/memory_dump_manager.h"
+#include "base/trace_event/process_memory_dump.h"
 #include "third_party/leveldatabase/env_chromium.h"
 #include "third_party/leveldatabase/src/include/leveldb/db.h"
 #include "third_party/leveldatabase/src/include/leveldb/iterator.h"
 #include "third_party/leveldatabase/src/include/leveldb/options.h"
 #include "third_party/leveldatabase/src/include/leveldb/status.h"
 #include "third_party/leveldatabase/src/include/leveldb/write_batch.h"
 #include "url/gurl.h"
 
 
 namespace {
@@ skipping 63 matching lines @@
   SessionStorageDatabase* session_storage_database_;
 };
 
 
 SessionStorageDatabase::SessionStorageDatabase(const base::FilePath& file_path)
     : file_path_(file_path),
       db_error_(false),
       is_inconsistent_(false),
       invalid_db_deleted_(false),
       operation_count_(0) {
+  base::trace_event::MemoryDumpManager::GetInstance()->RegisterDumpProvider(
+      this, base::ThreadTaskRunnerHandle::Get());

[michaeln, 2015/10/15 23:55:13]

The threading needs some work. This class is created on the main thread and
deleted on a worker pool thread.

DCHECK(!base::ThreadTaskRunnerHandle::IsSet()) is a valid assertion on worker
pool threads.

Does the MemoryDumpManager know about SequencedTaskRunners? Session storage
doesn't care about thread affinity but it does care about ordering.  It uses the
SequencedWorkerPool and SequencedTaskRunners for that. A lot of things care
about ordering more than thread affinity so modifying the dump manager to work
with them instead of ThreadTaskRunners would be a good change.

[Primiano Tucci (use gerrit), 2015/10/16 09:10:34]

There are mainly two reason why I restricted the manager to ThreadTaskRunners :
- I want to guarantee that Registration, Unregistration and OnMemoryDump calls
do not overlap. Restricting to a single thread felt the safe choice to me. But
is sounds like we might be able to get the same guarantee with STR, but I have
to think more on this.
- By using thread task runners I can make the manager smarter on the thread
hopping logic: if I have 20 dumpers registered on 5 different threads, I can
reshuffle the OnMemoryDump sequence grouping by thread and do only 5 thread hops
in total.

If I switch to STR, how do I figure out what is the smartest sequence of
hopping?
I guess the best choice would be to have a different code path for STR, and just
do uncoditional PostTasks all the times there.

 }
 
 SessionStorageDatabase::~SessionStorageDatabase() {
+  base::trace_event::MemoryDumpManager::GetInstance()->UnregisterDumpProvider(
+      this);
 }
 
 void SessionStorageDatabase::ReadAreaValues(const std::string& namespace_id,
                                             const GURL& origin,
                                             DOMStorageValuesMap* result) {
   // We don't create a database if it doesn't exist. In that case, there is
   // nothing to be added to the result.
   if (!LazyOpen(false))
     return;
   DBOperation operation(this);
@@ skipping 205 matching lines @@
     } else {
       // The key is of the form "namespace-<namespaceid>-<origin>".
       std::string origin = key.substr(current_namespace_start_key.length());
       (*namespaces_and_origins)[current_namespace_id].push_back(GURL(origin));
     }
   }
   db_->ReleaseSnapshot(options.snapshot);
   return true;
 }
 
+bool SessionStorageDatabase::OnMemoryDump(
+    const base::trace_event::MemoryDumpArgs& args,
+    base::trace_event::ProcessMemoryDump* pmd) {
+  if (!db_)
+    return true;
+
+  base::trace_event::MemoryAllocatorDump* dump =
+      pmd->CreateAllocatorDump("leveldb/session_storage_db");
+
+  base::AutoLock auto_lock(db_lock_);
+  std::string value;
+  uint64 size;
+  bool res = db_->GetProperty("leveldb.approximate-memory-usage", &value);
+  DCHECK(res);
+  base::StringToUint64(value, &size);
+
+  dump->AddScalar(base::trace_event::MemoryAllocatorDump::kNameSize,
+                  base::trace_event::MemoryAllocatorDump::kUnitsBytes, size);
+
+  // Memory is allocated from system allocator (malloc).
+  pmd->AddSuballocation(dump->guid(),
+                        base::trace_event::MemoryDumpManager::GetInstance()
+                            ->system_allocator_pool_name());
+  return true;
+}
+
 bool SessionStorageDatabase::LazyOpen(bool create_if_needed) {

[michaeln, 2015/10/15 23:55:13]

This might be a better place to Register with the dumpmgr but we need to make
the task runner available to this class.

   base::AutoLock auto_lock(db_lock_);
   if (db_error_ || is_inconsistent_) {
     // Don't try to open a database that we know has failed already.
     return false;
   }
   if (IsOpen())
     return true;
 
   if (!create_if_needed &&
       (!base::PathExists(file_path_) || base::IsDirectoryEmpty(file_path_))) {
@@ skipping 384 matching lines @@
 std::string SessionStorageDatabase::MapKey(const std::string& map_id,
                                            const std::string& key) {
   return base::StringPrintf("map-%s-%s", map_id.c_str(), key.c_str());
 }
 
 const char* SessionStorageDatabase::NextMapIdKey() {
   return "next-map-id";
 }
 
 }  // namespace content