base/metrics/stats_table_unittest.cc

   1 // Copyright (c) 2010 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/metrics/stats_counters.h"
   6 #include "base/metrics/stats_table.h"
   7 #include "base/shared_memory.h"
   8 #include "base/string_piece.h"
   9 #include "base/string_util.h"
  10 #include "base/test/multiprocess_test.h"
  11 #include "base/threading/platform_thread.h"
  12 #include "base/threading/simple_thread.h"
  13 #include "base/utf_string_conversions.h"
  14 #include "testing/gtest/include/gtest/gtest.h"
  15 #include "testing/multiprocess_func_list.h"
  16
  17 namespace base {
  18
  19 class StatsTableTest : public MultiProcessTest {
  20  public:
  21   void DeleteShmem(const std::string& name) {
  22     SharedMemory mem;
  23     mem.Delete(name);
  24   }
  25 };
  26
  27 // Open a StatsTable and verify that we can write to each of the
  28 // locations in the table.
  29 TEST_F(StatsTableTest, VerifySlots) {
  30   const std::string kTableName = "VerifySlotsStatTable";
  31   const int kMaxThreads = 1;
  32   const int kMaxCounter = 5;
  33   DeleteShmem(kTableName);
  34   StatsTable table(kTableName, kMaxThreads, kMaxCounter);
  35
  36   // Register a single thread.
  37   std::string thread_name = "mainThread";
  38   int slot_id = table.RegisterThread(thread_name);
  39   EXPECT_NE(slot_id, 0);
  40
  41   // Fill up the table with counters.
  42   std::string counter_base_name = "counter";
  43   for (int index = 0; index < kMaxCounter; index++) {
  44     std::string counter_name = counter_base_name;
  45     StringAppendF(&counter_name, "counter.ctr%d", index);
  46     int counter_id = table.FindCounter(counter_name);
  47     EXPECT_GT(counter_id, 0);
  48   }
  49
  50   // Try to allocate an additional thread.  Verify it fails.
  51   slot_id = table.RegisterThread("too many threads");
  52   EXPECT_EQ(slot_id, 0);
  53
  54   // Try to allocate an additional counter.  Verify it fails.
  55   int counter_id = table.FindCounter(counter_base_name);
  56   EXPECT_EQ(counter_id, 0);
  57
  58   DeleteShmem(kTableName);
  59 }
  60
  61 // CounterZero will continually be set to 0.
  62 const std::string kCounterZero = "CounterZero";
  63 // Counter1313 will continually be set to 1313.
  64 const std::string kCounter1313 = "Counter1313";
  65 // CounterIncrement will be incremented each time.
  66 const std::string kCounterIncrement = "CounterIncrement";
  67 // CounterDecrement will be decremented each time.
  68 const std::string kCounterDecrement = "CounterDecrement";
  69 // CounterMixed will be incremented by odd numbered threads and
  70 // decremented by even threads.
  71 const std::string kCounterMixed = "CounterMixed";
  72 // The number of thread loops that we will do.
  73 const int kThreadLoops = 100;
  74
  75 class StatsTableThread : public SimpleThread {
  76  public:
  77   StatsTableThread(std::string name, int id)
  78       : SimpleThread(name),
  79       id_(id) {}
  80   virtual void Run();
  81  private:
  82   int id_;
  83 };
  84
  85 void StatsTableThread::Run() {
  86   // Each thread will open the shared memory and set counters
  87   // concurrently in a loop.  We'll use some pauses to
  88   // mixup the thread scheduling.
  89
  90   StatsCounter zero_counter(kCounterZero);
  91   StatsCounter lucky13_counter(kCounter1313);
  92   StatsCounter increment_counter(kCounterIncrement);
  93   StatsCounter decrement_counter(kCounterDecrement);
  94   for (int index = 0; index < kThreadLoops; index++) {
  95     StatsCounter mixed_counter(kCounterMixed);  // create this one in the loop
  96     zero_counter.Set(0);
  97     lucky13_counter.Set(1313);
  98     increment_counter.Increment();
  99     decrement_counter.Decrement();
 100     if (id_ % 2)
 101       mixed_counter.Decrement();
 102     else
 103       mixed_counter.Increment();
 104     PlatformThread::Sleep(index % 10);   // short wait
 105   }
 106 }
 107
 108 // Create a few threads and have them poke on their counters.
 109 // Flaky, http://crbug.com/10611.
 110 TEST_F(StatsTableTest, FLAKY_MultipleThreads) {
 111   // Create a stats table.
 112   const std::string kTableName = "MultipleThreadStatTable";
 113   const int kMaxThreads = 20;
 114   const int kMaxCounter = 5;
 115   DeleteShmem(kTableName);
 116   StatsTable table(kTableName, kMaxThreads, kMaxCounter);
 117   StatsTable::set_current(&table);
 118
 119   EXPECT_EQ(0, table.CountThreadsRegistered());
 120
 121   // Spin up a set of threads to go bang on the various counters.
 122   // After we join the threads, we'll make sure the counters
 123   // contain the values we expected.
 124   StatsTableThread* threads[kMaxThreads];
 125
 126   // Spawn the threads.
 127   for (int index = 0; index < kMaxThreads; index++) {
 128     threads[index] = new StatsTableThread("MultipleThreadsTest", index);
 129     threads[index]->Start();
 130   }
 131
 132   // Wait for the threads to finish.
 133   for (int index = 0; index < kMaxThreads; index++) {
 134     threads[index]->Join();
 135     delete threads[index];
 136   }
 137
 138   StatsCounter zero_counter(kCounterZero);
 139   StatsCounter lucky13_counter(kCounter1313);
 140   StatsCounter increment_counter(kCounterIncrement);
 141   StatsCounter decrement_counter(kCounterDecrement);
 142   StatsCounter mixed_counter(kCounterMixed);
 143
 144   // Verify the various counters are correct.
 145   std::string name;
 146   name = "c:" + kCounterZero;
 147   EXPECT_EQ(0, table.GetCounterValue(name));
 148   name = "c:" + kCounter1313;
 149   EXPECT_EQ(1313 * kMaxThreads,
 150       table.GetCounterValue(name));
 151   name = "c:" + kCounterIncrement;
 152   EXPECT_EQ(kMaxThreads * kThreadLoops,
 153       table.GetCounterValue(name));
 154   name = "c:" + kCounterDecrement;
 155   EXPECT_EQ(-kMaxThreads * kThreadLoops,
 156       table.GetCounterValue(name));
 157   name = "c:" + kCounterMixed;
 158   EXPECT_EQ((kMaxThreads % 2) * kThreadLoops,
 159       table.GetCounterValue(name));
 160   EXPECT_EQ(0, table.CountThreadsRegistered());
 161
 162   DeleteShmem(kTableName);
 163 }
 164
 165 const std::string kMPTableName = "MultipleProcessStatTable";
 166
 167 MULTIPROCESS_TEST_MAIN(StatsTableMultipleProcessMain) {
 168   // Each process will open the shared memory and set counters
 169   // concurrently in a loop.  We'll use some pauses to
 170   // mixup the scheduling.
 171
 172   StatsTable table(kMPTableName, 0, 0);
 173   StatsTable::set_current(&table);
 174   StatsCounter zero_counter(kCounterZero);
 175   StatsCounter lucky13_counter(kCounter1313);
 176   StatsCounter increment_counter(kCounterIncrement);
 177   StatsCounter decrement_counter(kCounterDecrement);
 178   for (int index = 0; index < kThreadLoops; index++) {
 179     zero_counter.Set(0);
 180     lucky13_counter.Set(1313);
 181     increment_counter.Increment();
 182     decrement_counter.Decrement();
 183     PlatformThread::Sleep(index % 10);   // short wait
 184   }
 185   return 0;
 186 }
 187
 188 // Create a few processes and have them poke on their counters.
 189 // This test is slow and flaky http://crbug.com/10611
 190 TEST_F(StatsTableTest, FLAKY_MultipleProcesses) {
 191   // Create a stats table.
 192   const int kMaxProcs = 20;
 193   const int kMaxCounter = 5;
 194   DeleteShmem(kMPTableName);
 195   StatsTable table(kMPTableName, kMaxProcs, kMaxCounter);
 196   StatsTable::set_current(&table);
 197   EXPECT_EQ(0, table.CountThreadsRegistered());
 198
 199   // Spin up a set of processes to go bang on the various counters.
 200   // After we join the processes, we'll make sure the counters
 201   // contain the values we expected.
 202   ProcessHandle procs[kMaxProcs];
 203
 204   // Spawn the processes.
 205   for (int16 index = 0; index < kMaxProcs; index++) {
 206     procs[index] = this->SpawnChild("StatsTableMultipleProcessMain", false);
 207     EXPECT_NE(kNullProcessHandle, procs[index]);
 208   }
 209
 210   // Wait for the processes to finish.
 211   for (int index = 0; index < kMaxProcs; index++) {
 212     EXPECT_TRUE(WaitForSingleProcess(procs[index], 60 * 1000));
 213     CloseProcessHandle(procs[index]);
 214   }
 215
 216   StatsCounter zero_counter(kCounterZero);
 217   StatsCounter lucky13_counter(kCounter1313);
 218   StatsCounter increment_counter(kCounterIncrement);
 219   StatsCounter decrement_counter(kCounterDecrement);
 220
 221   // Verify the various counters are correct.
 222   std::string name;
 223   name = "c:" + kCounterZero;
 224   EXPECT_EQ(0, table.GetCounterValue(name));
 225   name = "c:" + kCounter1313;
 226   EXPECT_EQ(1313 * kMaxProcs,
 227       table.GetCounterValue(name));
 228   name = "c:" + kCounterIncrement;
 229   EXPECT_EQ(kMaxProcs * kThreadLoops,
 230       table.GetCounterValue(name));
 231   name = "c:" + kCounterDecrement;
 232   EXPECT_EQ(-kMaxProcs * kThreadLoops,
 233       table.GetCounterValue(name));
 234   EXPECT_EQ(0, table.CountThreadsRegistered());
 235
 236   DeleteShmem(kMPTableName);
 237 }
 238
 239 class MockStatsCounter : public StatsCounter {
 240  public:
 241   explicit MockStatsCounter(const std::string& name)
 242       : StatsCounter(name) {}
 243   int* Pointer() { return GetPtr(); }
 244 };
 245
 246 // Test some basic StatsCounter operations
 247 TEST_F(StatsTableTest, StatsCounter) {
 248   // Create a stats table.
 249   const std::string kTableName = "StatTable";
 250   const int kMaxThreads = 20;
 251   const int kMaxCounter = 5;
 252   DeleteShmem(kTableName);
 253   StatsTable table(kTableName, kMaxThreads, kMaxCounter);
 254   StatsTable::set_current(&table);
 255
 256   MockStatsCounter foo("foo");
 257
 258   // Test initial state.
 259   EXPECT_TRUE(foo.Enabled());
 260   ASSERT_NE(foo.Pointer(), static_cast<int*>(0));
 261   EXPECT_EQ(0, *(foo.Pointer()));
 262   EXPECT_EQ(0, table.GetCounterValue("c:foo"));
 263
 264   // Test Increment.
 265   while (*(foo.Pointer()) < 123) foo.Increment();
 266   EXPECT_EQ(123, table.GetCounterValue("c:foo"));
 267   foo.Add(0);
 268   EXPECT_EQ(123, table.GetCounterValue("c:foo"));
 269   foo.Add(-1);
 270   EXPECT_EQ(122, table.GetCounterValue("c:foo"));
 271
 272   // Test Set.
 273   foo.Set(0);
 274   EXPECT_EQ(0, table.GetCounterValue("c:foo"));
 275   foo.Set(100);
 276   EXPECT_EQ(100, table.GetCounterValue("c:foo"));
 277   foo.Set(-1);
 278   EXPECT_EQ(-1, table.GetCounterValue("c:foo"));
 279   foo.Set(0);
 280   EXPECT_EQ(0, table.GetCounterValue("c:foo"));
 281
 282   // Test Decrement.
 283   foo.Subtract(1);
 284   EXPECT_EQ(-1, table.GetCounterValue("c:foo"));
 285   foo.Subtract(0);
 286   EXPECT_EQ(-1, table.GetCounterValue("c:foo"));
 287   foo.Subtract(-1);
 288   EXPECT_EQ(0, table.GetCounterValue("c:foo"));
 289
 290   DeleteShmem(kTableName);
 291 }
 292
 293 class MockStatsCounterTimer : public StatsCounterTimer {
 294  public:
 295   explicit MockStatsCounterTimer(const std::string& name)
 296       : StatsCounterTimer(name) {}
 297
 298   TimeTicks start_time() { return start_time_; }
 299   TimeTicks stop_time() { return stop_time_; }
 300 };
 301
 302 // Test some basic StatsCounterTimer operations
 303 TEST_F(StatsTableTest, StatsCounterTimer) {
 304   // Create a stats table.
 305   const std::string kTableName = "StatTable";
 306   const int kMaxThreads = 20;
 307   const int kMaxCounter = 5;
 308   StatsTable table(kTableName, kMaxThreads, kMaxCounter);
 309   StatsTable::set_current(&table);
 310
 311   MockStatsCounterTimer bar("bar");
 312
 313   // Test initial state.
 314   EXPECT_FALSE(bar.Running());
 315   EXPECT_TRUE(bar.start_time().is_null());
 316   EXPECT_TRUE(bar.stop_time().is_null());
 317
 318   const int kRunMs = 100;
 319
 320   // Do some timing.
 321   bar.Start();
 322   PlatformThread::Sleep(kRunMs);
 323   bar.Stop();
 324   EXPECT_GT(table.GetCounterValue("t:bar"), 0);
 325   EXPECT_LE(kRunMs, table.GetCounterValue("t:bar"));
 326
 327   // Verify that timing again is additive.
 328   bar.Start();
 329   PlatformThread::Sleep(kRunMs);
 330   bar.Stop();
 331   EXPECT_GT(table.GetCounterValue("t:bar"), 0);
 332   EXPECT_LE(kRunMs * 2, table.GetCounterValue("t:bar"));
 333 }
 334
 335 // Test some basic StatsRate operations
 336 TEST_F(StatsTableTest, StatsRate) {
 337   // Create a stats table.
 338   const std::string kTableName = "StatTable";
 339   const int kMaxThreads = 20;
 340   const int kMaxCounter = 5;
 341   StatsTable table(kTableName, kMaxThreads, kMaxCounter);
 342   StatsTable::set_current(&table);
 343
 344   StatsRate baz("baz");
 345
 346   // Test initial state.
 347   EXPECT_FALSE(baz.Running());
 348   EXPECT_EQ(0, table.GetCounterValue("c:baz"));
 349   EXPECT_EQ(0, table.GetCounterValue("t:baz"));
 350
 351   const int kRunMs = 100;
 352
 353   // Do some timing.
 354   baz.Start();
 355   PlatformThread::Sleep(kRunMs);
 356   baz.Stop();
 357   EXPECT_EQ(1, table.GetCounterValue("c:baz"));
 358   EXPECT_LE(kRunMs, table.GetCounterValue("t:baz"));
 359
 360   // Verify that timing again is additive.
 361   baz.Start();
 362   PlatformThread::Sleep(kRunMs);
 363   baz.Stop();
 364   EXPECT_EQ(2, table.GetCounterValue("c:baz"));
 365   EXPECT_LE(kRunMs * 2, table.GetCounterValue("t:baz"));
 366 }
 367
 368 // Test some basic StatsScope operations
 369 TEST_F(StatsTableTest, StatsScope) {
 370   // Create a stats table.
 371   const std::string kTableName = "StatTable";
 372   const int kMaxThreads = 20;
 373   const int kMaxCounter = 5;
 374   DeleteShmem(kTableName);
 375   StatsTable table(kTableName, kMaxThreads, kMaxCounter);
 376   StatsTable::set_current(&table);
 377
 378   StatsCounterTimer foo("foo");
 379   StatsRate bar("bar");
 380
 381   // Test initial state.
 382   EXPECT_EQ(0, table.GetCounterValue("t:foo"));
 383   EXPECT_EQ(0, table.GetCounterValue("t:bar"));
 384   EXPECT_EQ(0, table.GetCounterValue("c:bar"));
 385
 386   const int kRunMs = 100;
 387
 388   // Try a scope.
 389   {
 390     StatsScope<StatsCounterTimer> timer(foo);
 391     StatsScope<StatsRate> timer2(bar);
 392     PlatformThread::Sleep(kRunMs);
 393   }
 394   EXPECT_LE(kRunMs, table.GetCounterValue("t:foo"));
 395   EXPECT_LE(kRunMs, table.GetCounterValue("t:bar"));
 396   EXPECT_EQ(1, table.GetCounterValue("c:bar"));
 397
 398   // Try a second scope.
 399   {
 400     StatsScope<StatsCounterTimer> timer(foo);
 401     StatsScope<StatsRate> timer2(bar);
 402     PlatformThread::Sleep(kRunMs);
 403   }
 404   EXPECT_LE(kRunMs * 2, table.GetCounterValue("t:foo"));
 405   EXPECT_LE(kRunMs * 2, table.GetCounterValue("t:bar"));
 406   EXPECT_EQ(2, table.GetCounterValue("c:bar"));
 407
 408   DeleteShmem(kTableName);
 409 }
 410
 411 }  // namespace base