base/process/process_metrics_unittest.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/process/process_metrics.h"
   6
   7 #include <sstream>
   8 #include <string>
   9
  10 #include "base/threading/thread.h"
  11 #include "testing/gtest/include/gtest/gtest.h"
  12
  13
  14 namespace base {
  15 namespace debug {
  16
  17 // Tests for SystemMetrics.
  18 // Exists as a class so it can be a friend of SystemMetrics.
  19 class SystemMetricsTest : public testing::Test {
  20  public:
  21   SystemMetricsTest() {}
  22
  23  private:
  24   DISALLOW_COPY_AND_ASSIGN(SystemMetricsTest);
  25 };
  26
  27 /////////////////////////////////////////////////////////////////////////////
  28
  29 #if defined(OS_LINUX) || defined(OS_ANDROID)
  30 TEST_F(SystemMetricsTest, IsValidDiskName) {
  31   std::string invalid_input1 = "";
  32   std::string invalid_input2 = "s";
  33   std::string invalid_input3 = "sdz+";
  34   std::string invalid_input4 = "hda0";
  35   std::string invalid_input5 = "mmcbl";
  36   std::string invalid_input6 = "mmcblka";
  37   std::string invalid_input7 = "mmcblkb";
  38   std::string invalid_input8 = "mmmblk0";
  39
  40   EXPECT_FALSE(IsValidDiskName(invalid_input1));
  41   EXPECT_FALSE(IsValidDiskName(invalid_input2));
  42   EXPECT_FALSE(IsValidDiskName(invalid_input3));
  43   EXPECT_FALSE(IsValidDiskName(invalid_input4));
  44   EXPECT_FALSE(IsValidDiskName(invalid_input5));
  45   EXPECT_FALSE(IsValidDiskName(invalid_input6));
  46   EXPECT_FALSE(IsValidDiskName(invalid_input7));
  47   EXPECT_FALSE(IsValidDiskName(invalid_input8));
  48
  49   std::string valid_input1 = "sda";
  50   std::string valid_input2 = "sdaaaa";
  51   std::string valid_input3 = "hdz";
  52   std::string valid_input4 = "mmcblk0";
  53   std::string valid_input5 = "mmcblk999";
  54
  55   EXPECT_TRUE(IsValidDiskName(valid_input1));
  56   EXPECT_TRUE(IsValidDiskName(valid_input2));
  57   EXPECT_TRUE(IsValidDiskName(valid_input3));
  58   EXPECT_TRUE(IsValidDiskName(valid_input4));
  59   EXPECT_TRUE(IsValidDiskName(valid_input5));
  60 }
  61
  62 TEST_F(SystemMetricsTest, ParseMeminfo) {
  63   struct SystemMemoryInfoKB meminfo;
  64   std::string invalid_input1 = "abc";
  65   std::string invalid_input2 = "MemTotal:";
  66   // Partial file with no MemTotal
  67   std::string invalid_input3 =
  68     "MemFree:         3913968 kB\n"
  69     "Buffers:         2348340 kB\n"
  70     "Cached:         49071596 kB\n"
  71     "SwapCached:           12 kB\n"
  72     "Active:         36393900 kB\n"
  73     "Inactive:       21221496 kB\n"
  74     "Active(anon):    5674352 kB\n"
  75     "Inactive(anon):   633992 kB\n";
  76   EXPECT_FALSE(ParseProcMeminfo(invalid_input1, &meminfo));
  77   EXPECT_FALSE(ParseProcMeminfo(invalid_input2, &meminfo));
  78   EXPECT_FALSE(ParseProcMeminfo(invalid_input3, &meminfo));
  79
  80   std::string valid_input1 =
  81     "MemTotal:        3981504 kB\n"
  82     "MemFree:          140764 kB\n"
  83     "Buffers:          116480 kB\n"
  84     "Cached:           406160 kB\n"
  85     "SwapCached:        21304 kB\n"
  86     "Active:          3152040 kB\n"
  87     "Inactive:         472856 kB\n"
  88     "Active(anon):    2972352 kB\n"
  89     "Inactive(anon):   270108 kB\n"
  90     "Active(file):     179688 kB\n"
  91     "Inactive(file):   202748 kB\n"
  92     "Unevictable:           0 kB\n"
  93     "Mlocked:               0 kB\n"
  94     "SwapTotal:       5832280 kB\n"
  95     "SwapFree:        3672368 kB\n"
  96     "Dirty:               184 kB\n"
  97     "Writeback:             0 kB\n"
  98     "AnonPages:       3101224 kB\n"
  99     "Mapped:           142296 kB\n"
 100     "Shmem:            140204 kB\n"
 101     "Slab:              54212 kB\n"
 102     "SReclaimable:      30936 kB\n"
 103     "SUnreclaim:        23276 kB\n"
 104     "KernelStack:        2464 kB\n"
 105     "PageTables:        24812 kB\n"
 106     "NFS_Unstable:          0 kB\n"
 107     "Bounce:                0 kB\n"
 108     "WritebackTmp:          0 kB\n"
 109     "CommitLimit:     7823032 kB\n"
 110     "Committed_AS:    7973536 kB\n"
 111     "VmallocTotal:   34359738367 kB\n"
 112     "VmallocUsed:      375940 kB\n"
 113     "VmallocChunk:   34359361127 kB\n"
 114     "DirectMap4k:       72448 kB\n"
 115     "DirectMap2M:     4061184 kB\n";
 116   // output from a much older kernel where the Active and Inactive aren't
 117   // broken down into anon and file and Huge Pages are enabled
 118   std::string valid_input2 =
 119     "MemTotal:       255908 kB\n"
 120     "MemFree:         69936 kB\n"
 121     "Buffers:         15812 kB\n"
 122     "Cached:         115124 kB\n"
 123     "SwapCached:          0 kB\n"
 124     "Active:          92700 kB\n"
 125     "Inactive:        63792 kB\n"
 126     "HighTotal:           0 kB\n"
 127     "HighFree:            0 kB\n"
 128     "LowTotal:       255908 kB\n"
 129     "LowFree:         69936 kB\n"
 130     "SwapTotal:      524280 kB\n"
 131     "SwapFree:       524200 kB\n"
 132     "Dirty:               4 kB\n"
 133     "Writeback:           0 kB\n"
 134     "Mapped:          42236 kB\n"
 135     "Slab:            25912 kB\n"
 136     "Committed_AS:   118680 kB\n"
 137     "PageTables:       1236 kB\n"
 138     "VmallocTotal:  3874808 kB\n"
 139     "VmallocUsed:      1416 kB\n"
 140     "VmallocChunk:  3872908 kB\n"
 141     "HugePages_Total:     0\n"
 142     "HugePages_Free:      0\n"
 143     "Hugepagesize:     4096 kB\n";
 144
 145   EXPECT_TRUE(ParseProcMeminfo(valid_input1, &meminfo));
 146   EXPECT_TRUE(meminfo.total == 3981504);
 147   EXPECT_TRUE(meminfo.free == 140764);
 148   EXPECT_TRUE(meminfo.buffers == 116480);
 149   EXPECT_TRUE(meminfo.cached == 406160);
 150   EXPECT_TRUE(meminfo.active_anon == 2972352);
 151   EXPECT_TRUE(meminfo.active_file == 179688);
 152   EXPECT_TRUE(meminfo.inactive_anon == 270108);
 153   EXPECT_TRUE(meminfo.inactive_file == 202748);
 154   EXPECT_TRUE(meminfo.swap_total == 5832280);
 155   EXPECT_TRUE(meminfo.swap_free == 3672368);
 156   EXPECT_TRUE(meminfo.dirty == 184);
 157 #if defined(OS_CHROMEOS)
 158   EXPECT_TRUE(meminfo.shmem == 140204);
 159   EXPECT_TRUE(meminfo.slab == 54212);
 160 #endif
 161   EXPECT_TRUE(ParseProcMeminfo(valid_input2, &meminfo));
 162   EXPECT_TRUE(meminfo.total == 255908);
 163   EXPECT_TRUE(meminfo.free == 69936);
 164   EXPECT_TRUE(meminfo.buffers == 15812);
 165   EXPECT_TRUE(meminfo.cached == 115124);
 166   EXPECT_TRUE(meminfo.swap_total == 524280);
 167   EXPECT_TRUE(meminfo.swap_free == 524200);
 168   EXPECT_TRUE(meminfo.dirty == 4);
 169 }
 170
 171 TEST_F(SystemMetricsTest, ParseVmstat) {
 172   struct SystemMemoryInfoKB meminfo;
 173   // part of vmstat from a 3.2 kernel with numa enabled
 174   std::string valid_input1 =
 175     "nr_free_pages 905104\n"
 176     "nr_inactive_anon 142478"
 177     "nr_active_anon 1520046\n"
 178     "nr_inactive_file 4481001\n"
 179     "nr_active_file 8313439\n"
 180     "nr_unevictable 5044\n"
 181     "nr_mlock 5044\n"
 182     "nr_anon_pages 1633780\n"
 183     "nr_mapped 104742\n"
 184     "nr_file_pages 12828218\n"
 185     "nr_dirty 245\n"
 186     "nr_writeback 0\n"
 187     "nr_slab_reclaimable 831609\n"
 188     "nr_slab_unreclaimable 41164\n"
 189     "nr_page_table_pages 31470\n"
 190     "nr_kernel_stack 1735\n"
 191     "nr_unstable 0\n"
 192     "nr_bounce 0\n"
 193     "nr_vmscan_write 406\n"
 194     "nr_vmscan_immediate_reclaim 281\n"
 195     "nr_writeback_temp 0\n"
 196     "nr_isolated_anon 0\n"
 197     "nr_isolated_file 0\n"
 198     "nr_shmem 28820\n"
 199     "nr_dirtied 84674644\n"
 200     "nr_written 75307109\n"
 201     "nr_anon_transparent_hugepages 0\n"
 202     "nr_dirty_threshold 1536206\n"
 203     "nr_dirty_background_threshold 768103\n"
 204     "pgpgin 30777108\n"
 205     "pgpgout 319023278\n"
 206     "pswpin 179\n"
 207     "pswpout 406\n"
 208     "pgalloc_dma 0\n"
 209     "pgalloc_dma32 20833399\n"
 210     "pgalloc_normal 1622609290\n"
 211     "pgalloc_movable 0\n"
 212     "pgfree 1644355583\n"
 213     "pgactivate 75391882\n"
 214     "pgdeactivate 4121019\n"
 215     "pgfault 2542879679\n"
 216     "pgmajfault 487192\n";
 217   std::string valid_input2 =
 218     "nr_free_pages 180125\n"
 219     "nr_inactive_anon 51\n"
 220     "nr_active_anon 38832\n"
 221     "nr_inactive_file 50171\n"
 222     "nr_active_file 47510\n"
 223     "nr_unevictable 0\n"
 224     "nr_mlock 0\n"
 225     "nr_anon_pages 38825\n"
 226     "nr_mapped 24043\n"
 227     "nr_file_pages 97733\n"
 228     "nr_dirty 0\n"
 229     "nr_writeback 0\n"
 230     "nr_slab_reclaimable 4032\n"
 231     "nr_slab_unreclaimable 2848\n"
 232     "nr_page_table_pages 1505\n"
 233     "nr_kernel_stack 626\n"
 234     "nr_unstable 0\n"
 235     "nr_bounce 0\n"
 236     "nr_vmscan_write 0\n"
 237     "nr_vmscan_immediate_reclaim 0\n"
 238     "nr_writeback_temp 0\n"
 239     "nr_isolated_anon 0\n"
 240     "nr_isolated_file 0\n"
 241     "nr_shmem 58\n"
 242     "nr_dirtied 435358\n"
 243     "nr_written 401258\n"
 244     "nr_anon_transparent_hugepages 0\n"
 245     "nr_dirty_threshold 18566\n"
 246     "nr_dirty_background_threshold 4641\n"
 247     "pgpgin 299464\n"
 248     "pgpgout 2437788\n"
 249     "pswpin 12\n"
 250     "pswpout 901\n"
 251     "pgalloc_normal 144213030\n"
 252     "pgalloc_high 164501274\n"
 253     "pgalloc_movable 0\n"
 254     "pgfree 308894908\n"
 255     "pgactivate 239320\n"
 256     "pgdeactivate 1\n"
 257     "pgfault 716044601\n"
 258     "pgmajfault 2023\n"
 259     "pgrefill_normal 0\n"
 260     "pgrefill_high 0\n"
 261     "pgrefill_movable 0\n";
 262   EXPECT_TRUE(ParseProcVmstat(valid_input1, &meminfo));
 263   EXPECT_TRUE(meminfo.pswpin == 179);
 264   EXPECT_TRUE(meminfo.pswpout == 406);
 265   EXPECT_TRUE(meminfo.pgmajfault == 487192);
 266   EXPECT_TRUE(ParseProcVmstat(valid_input2, &meminfo));
 267   EXPECT_TRUE(meminfo.pswpin == 12);
 268   EXPECT_TRUE(meminfo.pswpout == 901);
 269   EXPECT_TRUE(meminfo.pgmajfault == 2023);
 270 }
 271 #endif  // defined(OS_LINUX) || defined(OS_ANDROID)
 272
 273 #if defined(OS_LINUX) || defined(OS_ANDROID)
 274 TEST(SystemMetrics2Test, GetSystemMemoryInfo) {
 275   base::SystemMemoryInfoKB info;
 276   EXPECT_TRUE(base::GetSystemMemoryInfo(&info));
 277
 278   // Ensure each field received a value.
 279   EXPECT_GT(info.total, 0);
 280   EXPECT_GT(info.free, 0);
 281   EXPECT_GT(info.buffers, 0);
 282   EXPECT_GT(info.cached, 0);
 283   EXPECT_GT(info.active_anon, 0);
 284   EXPECT_GT(info.inactive_anon, 0);
 285   EXPECT_GT(info.active_file, 0);
 286   EXPECT_GT(info.inactive_file, 0);
 287
 288   // All the values should be less than the total amount of memory.
 289   EXPECT_LT(info.free, info.total);
 290   EXPECT_LT(info.buffers, info.total);
 291   EXPECT_LT(info.cached, info.total);
 292   EXPECT_LT(info.active_anon, info.total);
 293   EXPECT_LT(info.inactive_anon, info.total);
 294   EXPECT_LT(info.active_file, info.total);
 295   EXPECT_LT(info.inactive_file, info.total);
 296
 297 #if defined(OS_CHROMEOS)
 298   // Chrome OS exposes shmem.
 299   EXPECT_GT(info.shmem, 0);
 300   EXPECT_LT(info.shmem, info.total);
 301   // Chrome unit tests are not run on actual Chrome OS hardware, so gem_objects
 302   // and gem_size cannot be tested here.
 303 #endif
 304 }
 305 #endif  // defined(OS_LINUX) || defined(OS_ANDROID)
 306
 307 #if defined(OS_WIN)
 308 // TODO(estade): if possible, port this test.
 309 TEST(ProcessMetricsTest, CalcFreeMemory) {
 310   scoped_ptr<base::ProcessMetrics> metrics(
 311       base::ProcessMetrics::CreateProcessMetrics(::GetCurrentProcess()));
 312   ASSERT_TRUE(NULL != metrics.get());
 313
 314   bool using_tcmalloc = false;
 315
 316   // Detect if we are using tcmalloc
 317 #if !defined(NO_TCMALLOC)
 318   const char* chrome_allocator = getenv("CHROME_ALLOCATOR");
 319   if (!chrome_allocator || _stricmp(chrome_allocator, "tcmalloc") == 0)
 320     using_tcmalloc = true;
 321 #endif
 322
 323   // Typical values here is ~1900 for total and ~1000 for largest. Obviously
 324   // it depends in what other tests have done to this process.
 325   base::FreeMBytes free_mem1 = {0};
 326   EXPECT_TRUE(metrics->CalculateFreeMemory(&free_mem1));
 327   EXPECT_LT(10u, free_mem1.total);
 328   EXPECT_LT(10u, free_mem1.largest);
 329   EXPECT_GT(2048u, free_mem1.total);
 330   EXPECT_GT(2048u, free_mem1.largest);
 331   EXPECT_GE(free_mem1.total, free_mem1.largest);
 332   EXPECT_TRUE(NULL != free_mem1.largest_ptr);
 333
 334   // Allocate 20M and check again. It should have gone down.
 335   const int kAllocMB = 20;
 336   scoped_ptr<char[]> alloc(new char[kAllocMB * 1024 * 1024]);
 337   size_t expected_total = free_mem1.total - kAllocMB;
 338   size_t expected_largest = free_mem1.largest;
 339
 340   base::FreeMBytes free_mem2 = {0};
 341   EXPECT_TRUE(metrics->CalculateFreeMemory(&free_mem2));
 342   EXPECT_GE(free_mem2.total, free_mem2.largest);
 343   // This test is flaky when using tcmalloc, because tcmalloc
 344   // allocation strategy sometimes results in less than the
 345   // full drop of 20Mb of free memory.
 346   if (!using_tcmalloc)
 347     EXPECT_GE(expected_total, free_mem2.total);
 348   EXPECT_GE(expected_largest, free_mem2.largest);
 349   EXPECT_TRUE(NULL != free_mem2.largest_ptr);
 350 }
 351 #endif  // defined(OS_WIN)
 352
 353 #if defined(OS_LINUX) || defined(OS_ANDROID)
 354 TEST(ProcessMetricsTest, ParseProcStatCPU) {
 355   // /proc/self/stat for a process running "top".
 356   const char kTopStat[] = "960 (top) S 16230 960 16230 34818 960 "
 357       "4202496 471 0 0 0 "
 358       "12 16 0 0 "  // <- These are the goods.
 359       "20 0 1 0 121946157 15077376 314 18446744073709551615 4194304 "
 360       "4246868 140733983044336 18446744073709551615 140244213071219 "
 361       "0 0 0 138047495 0 0 0 17 1 0 0 0 0 0";
 362   EXPECT_EQ(12 + 16, base::ParseProcStatCPU(kTopStat));
 363
 364   // cat /proc/self/stat on a random other machine I have.
 365   const char kSelfStat[] = "5364 (cat) R 5354 5364 5354 34819 5364 "
 366       "0 142 0 0 0 "
 367       "0 0 0 0 "  // <- No CPU, apparently.
 368       "16 0 1 0 1676099790 2957312 114 4294967295 134512640 134528148 "
 369       "3221224832 3221224344 3086339742 0 0 0 0 0 0 0 17 0 0 0";
 370
 371   EXPECT_EQ(0, base::ParseProcStatCPU(kSelfStat));
 372 }
 373 #endif // defined(OS_LINUX) || defined(OS_ANDROID)
 374
 375 // Disable on Android because base_unittests runs inside a Dalvik VM that
 376 // starts and stop threads (crbug.com/175563).
 377 #if defined(OS_LINUX)
 378 TEST(ProcessMetricsTest, GetNumberOfThreads) {
 379   const base::ProcessHandle current = base::GetCurrentProcessHandle();
 380   const int initial_threads = base::GetNumberOfThreads(current);
 381   ASSERT_GT(initial_threads, 0);
 382   const int kNumAdditionalThreads = 10;
 383   {
 384     scoped_ptr<base::Thread> my_threads[kNumAdditionalThreads];
 385     for (int i = 0; i < kNumAdditionalThreads; ++i) {
 386       my_threads[i].reset(new base::Thread("GetNumberOfThreadsTest"));
 387       my_threads[i]->Start();
 388       ASSERT_EQ(base::GetNumberOfThreads(current), initial_threads + 1 + i);
 389     }
 390   }
 391   // The Thread destructor will stop them.
 392   ASSERT_EQ(initial_threads, base::GetNumberOfThreads(current));
 393 }
 394 #endif  // defined(OS_LINUX)
 395
 396 }  // namespace debug
 397 }  // namespace base