base: Introduce SharedMemoryTracker for POSIX (but not macOS)

base/memory/shared_memory_tracker.cc

Index: base/memory/shared_memory_tracker.cc
diff --git a/base/memory/shared_memory_tracker.cc b/base/memory/shared_memory_tracker.cc
new file mode 100644
index 0000000000000000000000000000000000000000..a436bc5ca66439a04fb5475e1ab7a4abb66f28c0
--- /dev/null
+++ b/base/memory/shared_memory_tracker.cc
@@ -0,0 +1,82 @@
+// Copyright 2017 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 "base/memory/shared_memory_tracker.h"
+
+#include "base/memory/shared_memory.h"
+#include "base/strings/stringprintf.h"
+#include "base/trace_event/memory_dump_manager.h"
+#include "base/trace_event/process_memory_dump.h"
+
+namespace base {
+
+static const char* kSharedMemoryDumpName = "shared_memory";

[Primiano Tucci (use gerrit), 2017/01/27 20:09:49]

you use this only in one place. I'd just inline it.
(also as per code style this should be array type, i.e. const char
kSharedMemoryDumpName[]")

[hajimehoshi, 2017/02/07 12:33:44]

Done.

+
+SharedMemoryTracker* SharedMemoryTracker::GetInstance() {
+  return base::Singleton<SharedMemoryTracker, base::LeakySingletonTraits<
+                                                  SharedMemoryTracker>>::get();
+}
+
+bool SharedMemoryTracker::OnMemoryDump(
+    const base::trace_event::MemoryDumpArgs& args,
+    base::trace_event::ProcessMemoryDump* pmd) {
+  for (auto& bucket : buckets_) {
+    base::AutoLock lock(bucket.lock);
+    for (const auto& usage : bucket.usages) {
+      SharedMemory::Id id;
+      usage.first->GetUniqueId(&id);

[danakj, 2017/01/27 16:56:42]

I think you need to consolidate these ids first cuz multiple SharedMemory may
have the same id right? (I think that's the test failures too?)

I was expecting an unordered_map<std::pair<dev_t, ino_t>, size_t> and a fisrt
walk thru the buckets_ summing everything into this temporary set.

Then if you want to avoid calling fstat so much, it'd be possible (as a
followup?) to store the id in the buckets_ as well and reuse it when it's
available.

[Primiano Tucci (use gerrit), 2017/01/27 20:09:49]

Hmm interesting. I would have *not* expected that we mmap the same SHM handle
twice within the same process (but I wouldn't be entirely surprised if this was
WAI). The test is failing precisely for this reason.
Can you check where the double mmaps come from?
It could be WAI... but also it might be a red herring about GetUniqueId not
really being unique. I would feel better if we can check that test and
understand where the double map comes from.
+1, if we end up having to deal with duplicate mappings.
(remember then that when you will count virtual_size, that one has to be
double-counted though)
I guess alternatively that could be  cached by in the SharedMemory object
itself, and computed lazily on the first call to GetUniqueId() ?

[hajimehoshi, 2017/02/07 12:33:44]

Hmm, I also didn't expect such situation like primiano@. I have no idea what is
happening. I'll add tests later.
Done.
primiano@'s idea looks good. As fstat is called only on OnMemoryDump and IMO
speed optimization is not urgent here, I think this fix can be in another CL.

[hajimehoshi, 2017/02/10 11:05:58]

FYI: This happens when the ID is 0. fstat(3) fails when the file descripter is
-1, and the file descripter becomes -1 when TakeHandle is called. This CL didn't
consider TakeHandle. I'll fix this.

+      std::string dump_name = base::StringPrintf(
+          "%s/%lld.%lld", kSharedMemoryDumpName,
+          static_cast<long long>(id.first), static_cast<long long>(id.second));
+      auto guid = base::trace_event::MemoryAllocatorDumpGuid(dump_name);
+      base::trace_event::MemoryAllocatorDump* local_dump =
+          pmd->CreateAllocatorDump(dump_name);
+      // TODO(hajimehoshi): The size is not resident size but virtual size so
+      // far. Fix this to record resident size.
+      local_dump->AddScalar(base::trace_event::MemoryAllocatorDump::kNameSize,
+                            base::trace_event::MemoryAllocatorDump::kUnitsBytes,
+                            usage.second);
+      base::trace_event::MemoryAllocatorDump* global_dump =
+          pmd->CreateSharedGlobalAllocatorDump(guid);
+      global_dump->AddScalar(
+          base::trace_event::MemoryAllocatorDump::kNameSize,
+          base::trace_event::MemoryAllocatorDump::kUnitsBytes, usage.second);
+      // TOOD(hajimehoshi): Detect which the shared memory comes from browser,
+      // renderer or GPU process.
+      // TODO(hajimehoshi): Shared memory reported by GPU and discardable is
+      // currently double-counted. Add ownership edges to avoid this.
+      pmd->AddOwnershipEdge(local_dump->guid(), global_dump->guid());
+    }
+  }
+  return true;
+}
+
+bool SharedMemoryTracker::IncrementMemoryUsage(
+    const SharedMemory& shared_memory) {
+  int bucket = reinterpret_cast<uintptr_t>(&shared_memory) % kTrackerBucketNum;
+  base::AutoLock lock(buckets_[bucket].lock);

[danakj, 2017/01/27 16:56:42]

nit: name the AutoLock |hold|. It's not a lock, it holds a lock.

[hajimehoshi, 2017/02/07 12:33:44]

Done.

+  buckets_[bucket].usages[&shared_memory] = shared_memory.mapped_size();
+  return true;
+}
+
+bool SharedMemoryTracker::DecrementMemoryUsage(
+    const SharedMemory& shared_memory) {
+  int bucket = reinterpret_cast<uintptr_t>(&shared_memory) % kTrackerBucketNum;
+  base::AutoLock lock(buckets_[bucket].lock);

[danakj, 2017/01/27 16:56:42]

same here

[hajimehoshi, 2017/02/07 12:33:44]

Done.

+  buckets_[bucket].usages.erase(&shared_memory);
+  return true;
+}
+
+SharedMemoryTracker::SharedMemoryTracker() {
+  base::trace_event::MemoryDumpManager::GetInstance()->RegisterDumpProvider(
+      this, "SharedMemoryTracker", nullptr);
+}
+
+SharedMemoryTracker::~SharedMemoryTracker() = default;
+
+SharedMemoryTracker::TrackerBucket::TrackerBucket() = default;
+
+SharedMemoryTracker::TrackerBucket::~TrackerBucket() = default;
+
+}  // namespace