Add new wired memory metric to memory-infra dumps.

base/process/process_metrics_unittest.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 "base/process/process_metrics.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <sstream>
 #include <string>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/macros.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/sys_info.h"
 #include "base/test/multiprocess_test.h"
 #include "base/threading/thread.h"
 #include "build/build_config.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/multiprocess_func_list.h"
 
+#if defined(OS_MACOSX)
+#include <sys/mman.h>
+
+#include "base/memory/free_deleter.h"
+#endif
+
 namespace base {
 namespace debug {
 
 #if defined(OS_LINUX) || defined(OS_CHROMEOS)
 namespace {
 
 void BusyWork(std::vector<std::string>* vec) {
   int64_t test_value = 0;
   for (int i = 0; i < 100000; ++i) {
     ++test_value;
     vec->push_back(Int64ToString(test_value));
   }
 }
 
 }  // namespace
 #endif  // defined(OS_LINUX) || defined(OS_CHROMEOS)
 
 // Tests for SystemMetrics.
 // Exists as a class so it can be a friend of SystemMetrics.
 class SystemMetricsTest : public testing::Test {
  public:
   SystemMetricsTest() {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(SystemMetricsTest);
 };
 
 /////////////////////////////////////////////////////////////////////////////
 
+#if defined(OS_MACOSX)
+TEST_F(SystemMetricsTest, WiredBytes) {
+  ProcessHandle handle = GetCurrentProcessHandle();
+  std::unique_ptr<ProcessMetrics> metrics(
+      ProcessMetrics::CreateProcessMetrics(handle, nullptr));
+
+  size_t initial_wired_bytes;
+  bool result =
+      metrics->GetMemoryBytes(nullptr, nullptr, nullptr, &initial_wired_bytes);
+  ASSERT_TRUE(result);
+
+  size_t size = 999 * PAGE_SIZE;
+  std::unique_ptr<char, base::FreeDeleter> memory(

[Primiano Tucci (use gerrit), 2017/03/28 20:32:54]

just std::unique_ptr<char[])(new char[size)); ?

[erikchen, 2017/03/30 00:03:14]

Done.

+      static_cast<char*>(malloc(size)));
+  int r = mlock(memory.get(), size);
+  ASSERT_EQ(r, 0);
+
+  size_t new_wired_bytes;
+  result = metrics->GetMemoryBytes(nullptr, nullptr, nullptr, &new_wired_bytes);
+  ASSERT_TRUE(result);
+  EXPECT_EQ(initial_wired_bytes + size, new_wired_bytes);
+
+  r = munlock(memory.get(), size);
+  ASSERT_EQ(r, 0);
+
+  result = metrics->GetMemoryBytes(nullptr, nullptr, nullptr, &new_wired_bytes);
+  ASSERT_TRUE(result);
+  EXPECT_EQ(initial_wired_bytes, new_wired_bytes);

[Primiano Tucci (use gerrit), 2017/03/28 20:32:54]

I got bitten in the past by this sort of tests. The thing that did bite me is
the fact that gtest might run other things on its own thread. Not sure how
likely is to end up mlocking memory from random (gtest) code.
In doubt, the sort of pattern that I used in the past was:
- Lock(X) with X somewhat big (say ~MBs)
- assert that locked >= X/2 (/2 to compensate for gtest unlocking something else
in the meantime)

[Mark Mentovai, 2017/03/28 20:56:11]

Is gtest really running its own threads? That’s surprising.

But yeah, you should deal with this, regardless of who’s starting the threads.
I’ve certainly seen trouble with other tests in the same process leaking threads
(or even not leaking them, just spinning up singleton threads that wind up not
quiescent), and a bunch of trouble with threads started by the OS (specifically
on Android, but also specifically on macOS, and also specifically on Windows…so
everywhere).

[erikchen, 2017/03/30 00:03:14]

Done.

+}
+#endif  // defined(OS_MACOSX)
+
 #if defined(OS_LINUX) || defined(OS_ANDROID)
 TEST_F(SystemMetricsTest, IsValidDiskName) {
   std::string invalid_input1 = "";
   std::string invalid_input2 = "s";
   std::string invalid_input3 = "sdz+";
   std::string invalid_input4 = "hda0";
   std::string invalid_input5 = "mmcbl";
   std::string invalid_input6 = "mmcblka";
   std::string invalid_input7 = "mmcblkb";
   std::string invalid_input8 = "mmmblk0";
@@ skipping 456 matching lines @@
 
   std::unique_ptr<ProcessMetrics> metrics(
       ProcessMetrics::CreateProcessMetrics(spawn_child.process.Handle()));
   EXPECT_EQ(0, metrics->GetOpenFdCount());
   ASSERT_TRUE(spawn_child.process.Terminate(0, true));
 }
 #endif  // defined(OS_LINUX)
 
 }  // namespace debug
 }  // namespace base