Merged third_party/tcmalloc/vendor/src(google-perftools r87) into...

third_party/tcmalloc/chromium/src/tests/profile-handler_unittest.cc

Index: third_party/tcmalloc/chromium/src/tests/profile-handler_unittest.cc
===================================================================
--- third_party/tcmalloc/chromium/src/tests/profile-handler_unittest.cc	(revision 41942)
+++ third_party/tcmalloc/chromium/src/tests/profile-handler_unittest.cc	(working copy)
@@ -8,8 +8,9 @@
 #include "profile-handler.h"
 
 #include <assert.h>
+#include <pthread.h>
 #include <sys/time.h>
-#include <pthread.h>
+#include <time.h>
 #include "base/logging.h"
 #include "base/simple_mutex.h"
 
@@ -46,19 +47,41 @@
   bool joinable_;
 };
 
-// Sleep interval in usecs. To ensure a SIGPROF timer interrupt under heavy
-// load, this is set to a 20x of ProfileHandler timer interval (i.e 100Hz)
-// TODO(nabeelmian) Under very heavy loads, the worker thread may not accumulate
-// enough cpu usage to get a profile tick.
-int kSleepInterval = 200000;
+// Sleep interval in nano secs. ITIMER_PROF goes off only afer the specified CPU
+// time is consumed. Under heavy load this process may no get scheduled in a
+// timely fashion. Therefore, give enough time (20x of ProfileHandle timer
+// interval 10ms (100Hz)) for this process to accumulate enought CPU time to get
+// a profile tick.
+int kSleepInterval = 200000000;
 
+// Sleep interval in nano secs. To ensure that if the timer has expired it is
+// reset.
+int kTimerResetInterval = 5000000;
+
 // Whether each thread has separate timers.
 static bool timer_separate_ = false;
+static int timer_type_ = ITIMER_PROF;
+static int signal_number_ = SIGPROF;
 
+// Delays processing by the specified number of nano seconds. 'delay_ns'
+// must be less than the number of nano seconds in a second (1000000000).
+void Delay(int delay_ns) {
+  static const int kNumNSecInSecond = 1000000000;
+  EXPECT_LT(delay_ns, kNumNSecInSecond);
+  struct timespec delay = { 0, delay_ns };
+  nanosleep(&delay, 0);
+}
+
 // Checks whether the profile timer is enabled for the current thread.
 bool IsTimerEnabled() {
   itimerval current_timer;
-  EXPECT_EQ(0, getitimer(ITIMER_PROF, &current_timer));
+  EXPECT_EQ(0, getitimer(timer_type_, &current_timer));
+  if ((current_timer.it_value.tv_sec == 0) &&
+      (current_timer.it_value.tv_usec != 0)) {
+    // May be the timer has expired. Sleep for a bit and check again.
+    Delay(kTimerResetInterval);
+    EXPECT_EQ(0, getitimer(timer_type_, &current_timer));
+  }
   return (current_timer.it_value.tv_sec != 0 ||
           current_timer.it_value.tv_usec != 0);
 }
@@ -160,11 +183,15 @@
 
   // Determines whether threads have separate timers.
   static void SetUpTestCase() {
+    timer_type_ = (getenv("CPUPROFILE_REALTIME") ? ITIMER_REAL : ITIMER_PROF);
+    signal_number_ = (getenv("CPUPROFILE_REALTIME") ? SIGALRM : SIGPROF);
+
     timer_separate_ = threads_have_separate_timers();
+    Delay(kTimerResetInterval);
   }
 
-  // Sets up the profile timers and SIGPROF handler in a known state. It does
-  // the following:
+  // Sets up the profile timers and SIGPROF/SIGALRM handler in a known state.
+  // It does the following:
   // 1. Unregisters all the callbacks, stops the timer (if shared) and
   //    clears out timer_sharing state in the ProfileHandler. This clears
   //    out any state left behind by the previous test or during module
@@ -176,7 +203,7 @@
     // Reset the state of ProfileHandler between each test. This unregisters
     // all callbacks, stops timer (if shared) and clears timer sharing state.
     ProfileHandlerReset();
-    EXPECT_EQ(GetCallbackCount(), 0);
+    EXPECT_EQ(0, GetCallbackCount());
     VerifyDisabled();
     // ProfileHandler requires at least two threads to be registerd to determine
     // whether timers are shared.
@@ -213,7 +240,7 @@
     busy_worker_->Start();
     // Wait for worker to start up and register with the ProfileHandler.
     // TODO(nabeelmian) This may not work under very heavy load.
-    usleep(kSleepInterval);
+    Delay(kSleepInterval);
   }
 
   // Stops the worker thread.
@@ -223,10 +250,10 @@
     delete busy_worker_;
   }
 
-  // Checks whether SIGPROF signal handler is enabled.
+  // Checks whether SIGPROF/SIGALRM signal handler is enabled.
   bool IsSignalEnabled() {
     struct sigaction sa;
-    CHECK_EQ(sigaction(SIGPROF, NULL, &sa), 0);
+    CHECK_EQ(sigaction(signal_number_, NULL, &sa), 0);
     return ((sa.sa_handler == SIG_IGN) || (sa.sa_handler == SIG_DFL)) ?
         false : true;
   }
@@ -257,7 +284,7 @@
     uint64 interrupts_before = GetInterruptCount();
     // Sleep for a bit and check that tick counter is making progress.
     int old_tick_count = tick_counter;
-    usleep(kSleepInterval);
+    Delay(kSleepInterval);
     int new_tick_count = tick_counter;
     EXPECT_GT(new_tick_count, old_tick_count);
     uint64 interrupts_after = GetInterruptCount();
@@ -268,9 +295,9 @@
   void VerifyUnregistration(const int& tick_counter) {
     // Sleep for a bit and check that tick counter is not making progress.
     int old_tick_count = tick_counter;
-    usleep(kSleepInterval);
+    Delay(kSleepInterval);
     int new_tick_count = tick_counter;
-    EXPECT_EQ(new_tick_count, old_tick_count);
+    EXPECT_EQ(old_tick_count, new_tick_count);
     // If no callbacks, signal handler and shared timer should be disabled.
     if (GetCallbackCount() == 0) {
       EXPECT_FALSE(IsSignalEnabled());
@@ -282,13 +309,13 @@
     }
   }
 
-  // Verifies that the SIGPROF interrupt handler is disabled and the timer,
-  // if shared, is disabled. Expects the worker to be running.
+  // Verifies that the SIGPROF/SIGALRM interrupt handler is disabled and the
+  // timer, if shared, is disabled. Expects the worker to be running.
   void VerifyDisabled() {
     // Check that the signal handler is disabled.
     EXPECT_FALSE(IsSignalEnabled());
     // Check that the callback count is 0.
-    EXPECT_EQ(GetCallbackCount(), 0);
+    EXPECT_EQ(0, GetCallbackCount());
     // Check that the timer is disabled if shared, enabled otherwise.
     if (timer_separate_) {
       EXPECT_TRUE(IsTimerEnabled());
@@ -297,11 +324,27 @@
     }
     // Verify that the ProfileHandler is not accumulating profile ticks.
     uint64 interrupts_before = GetInterruptCount();
-    usleep(kSleepInterval);
+    Delay(kSleepInterval);
     uint64 interrupts_after = GetInterruptCount();
-    EXPECT_EQ(interrupts_after, interrupts_before);
+    EXPECT_EQ(interrupts_before, interrupts_after);
   }
 
+  // Registers a callback and waits for kTimerResetInterval for timers to get
+  // reset.
+  ProfileHandlerToken* RegisterCallback(void* callback_arg) {
+    ProfileHandlerToken* token = ProfileHandlerRegisterCallback(
+        TickCounter, callback_arg);
+    Delay(kTimerResetInterval);
+    return token;
+  }
+
+  // Unregisters a callback and waits for kTimerResetInterval for timers to get
+  // reset.
+  void UnregisterCallback(ProfileHandlerToken* token) {
+    ProfileHandlerUnregisterCallback(token);
+    Delay(kTimerResetInterval);
+  }
+
   // Busy worker thread to accumulate cpu usage.
   BusyThread* busy_worker_;
 
@@ -336,10 +379,9 @@
 // ProfileHandlerUnregisterCallback.
 TEST_F(ProfileHandlerTest, RegisterUnregisterCallback) {
   int tick_count = 0;
-  ProfileHandlerToken* token = ProfileHandlerRegisterCallback(
-      TickCounter, &tick_count);
+  ProfileHandlerToken* token = RegisterCallback(&tick_count);
   VerifyRegistration(tick_count);
-  ProfileHandlerUnregisterCallback(token);
+  UnregisterCallback(token);
   VerifyUnregistration(tick_count);
 }
 
@@ -347,31 +389,29 @@
 TEST_F(ProfileHandlerTest, MultipleCallbacks) {
   // Register first callback.
   int first_tick_count;
-  ProfileHandlerToken* token1 = ProfileHandlerRegisterCallback(
-      TickCounter, &first_tick_count);
+  ProfileHandlerToken* token1 = RegisterCallback(&first_tick_count);
   // Check that callback was registered correctly.
   VerifyRegistration(first_tick_count);
-  EXPECT_EQ(GetCallbackCount(), 1);
+  EXPECT_EQ(1, GetCallbackCount());
 
   // Register second callback.
   int second_tick_count;
-  ProfileHandlerToken* token2 = ProfileHandlerRegisterCallback(
-      TickCounter, &second_tick_count);
+  ProfileHandlerToken* token2 = RegisterCallback(&second_tick_count);
   // Check that callback was registered correctly.
   VerifyRegistration(second_tick_count);
-  EXPECT_EQ(GetCallbackCount(), 2);
+  EXPECT_EQ(2, GetCallbackCount());
 
   // Unregister first callback.
-  ProfileHandlerUnregisterCallback(token1);
+  UnregisterCallback(token1);
   VerifyUnregistration(first_tick_count);
-  EXPECT_EQ(GetCallbackCount(), 1);
+  EXPECT_EQ(1, GetCallbackCount());
   // Verify that second callback is still registered.
   VerifyRegistration(second_tick_count);
 
   // Unregister second callback.
-  ProfileHandlerUnregisterCallback(token2);
+  UnregisterCallback(token2);
   VerifyUnregistration(second_tick_count);
-  EXPECT_EQ(GetCallbackCount(), 0);
+  EXPECT_EQ(0, GetCallbackCount());
 
   // Verify that the signal handler and timers are correctly disabled.
   VerifyDisabled();
@@ -382,15 +422,15 @@
   // Verify that the profile timer interrupt is disabled.
   VerifyDisabled();
   int first_tick_count;
-  ProfileHandlerRegisterCallback(TickCounter, &first_tick_count);
+  RegisterCallback(&first_tick_count);
   VerifyRegistration(first_tick_count);
-  EXPECT_EQ(GetCallbackCount(), 1);
+  EXPECT_EQ(1, GetCallbackCount());
 
   // Register second callback.
   int second_tick_count;
-  ProfileHandlerRegisterCallback(TickCounter, &second_tick_count);
+  RegisterCallback(&second_tick_count);
   VerifyRegistration(second_tick_count);
-  EXPECT_EQ(GetCallbackCount(), 2);
+  EXPECT_EQ(2, GetCallbackCount());
 
   // Reset the profile handler and verify that callback were correctly
   // unregistered and timer/signal are disabled.
@@ -409,7 +449,7 @@
   // the signal handler and reset the timer sharing state in the Profile
   // Handler.
   ProfileHandlerReset();
-  EXPECT_EQ(GetCallbackCount(), 0);
+  EXPECT_EQ(0, GetCallbackCount());
   VerifyDisabled();
 
   // Start the worker. At this time ProfileHandler doesn't know if timers are
@@ -417,14 +457,14 @@
   StartWorker();
   // Register a callback and check that profile ticks are being delivered.
   int tick_count;
-  ProfileHandlerRegisterCallback(TickCounter, &tick_count);
-  EXPECT_EQ(GetCallbackCount(), 1);
+  RegisterCallback(&tick_count);
+  EXPECT_EQ(1, GetCallbackCount());
   VerifyRegistration(tick_count);
 
   // Register a second thread and verify that timer and signal handler are
   // correctly enabled.
   RegisterThread();
-  EXPECT_EQ(GetCallbackCount(), 1);
+  EXPECT_EQ(1, GetCallbackCount());
   EXPECT_TRUE(IsTimerEnabled());
   EXPECT_TRUE(IsSignalEnabled());
 }