Merge r77 from upstream tcmalloc to the local chromium branch....

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

 // Copyright 2009 Google Inc. All Rights Reserved.
 // Author: Nabeel Mian (nabeelmian@google.com)
 //         Chris Demetriou (cgd@google.com)
 //
 // This file contains the unit tests for profile-handler.h interface.
 
 #include "config.h"
 #include "profile-handler.h"
 
 #include <assert.h>
+#include <sys/time.h>
 #include <pthread.h>
-#include <sys/time.h>
-#include <time.h>
 #include "base/logging.h"
 #include "base/simple_mutex.h"
 
 // Some helpful macros for the test class
 #define TEST_F(cls, fn)    void cls :: fn()
 
 namespace {
 
 // TODO(csilvers): error-checking on the pthreads routines
 class Thread {
@@ skipping 16 matching lines @@
  private:
   static void* DoRun(void* cls) {
     ProfileHandlerRegisterThread();
     reinterpret_cast<Thread*>(cls)->Run();
     return NULL;
   }
   pthread_t thread_;
   bool joinable_;
 };
 
-// timespec of the sleep interval. To ensure a SIGPROF timer interrupt under
-// heavy load, this is set to a 20x of ProfileHandler timer interval (i.e 100Hz)
+// 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.
-const struct timespec sleep_interval = { 0, 200000000 };  // 200 ms
+int kSleepInterval = 200000;
 
 // Whether each thread has separate timers.
 static bool timer_separate_ = false;
 
 // Checks whether the profile timer is enabled for the current thread.
 bool IsTimerEnabled() {
   itimerval current_timer;
   EXPECT_EQ(0, getitimer(ITIMER_PROF, &current_timer));
   return (current_timer.it_value.tv_sec != 0 ||
           current_timer.it_value.tv_usec != 0);
@@ skipping 142 matching lines @@
 
   // Starts a busy worker thread to accumulate cpu time. There should be only
   // one busy worker running. This is required for the case where there are
   // separate timers for each thread.
   void StartWorker() {
     busy_worker_ = new BusyThread();
     busy_worker_->SetJoinable(true);
     busy_worker_->Start();
     // Wait for worker to start up and register with the ProfileHandler.
     // TODO(nabeelmian) This may not work under very heavy load.
-    nanosleep(&sleep_interval, NULL);
+    usleep(kSleepInterval);
   }
 
   // Stops the worker thread.
   void StopWorker() {
     busy_worker_->set_stop_work(true);
     busy_worker_->Join();
     delete busy_worker_;
   }
 
   // Checks whether SIGPROF signal handler is enabled.
@@ skipping 23 matching lines @@
   void VerifyRegistration(const int& tick_counter) {
     // Check the callback count.
     EXPECT_GT(GetCallbackCount(), 0);
     // Check that the profile timer is enabled.
     EXPECT_TRUE(IsTimerEnabled());
     // Check that the signal handler is enabled.
     EXPECT_TRUE(IsSignalEnabled());
     uint64 interrupts_before = GetInterruptCount();
     // Sleep for a bit and check that tick counter is making progress.
     int old_tick_count = tick_counter;
-    nanosleep(&sleep_interval, NULL);
+    usleep(kSleepInterval);
     int new_tick_count = tick_counter;
     EXPECT_GT(new_tick_count, old_tick_count);
     uint64 interrupts_after = GetInterruptCount();
     EXPECT_GT(interrupts_after, interrupts_before);
   }
 
   // Verifies that a callback is not receiving profile ticks.
   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;
-    nanosleep(&sleep_interval, NULL);
+    usleep(kSleepInterval);
     int new_tick_count = tick_counter;
     EXPECT_EQ(new_tick_count, old_tick_count);
     // If no callbacks, signal handler and shared timer should be disabled.
     if (GetCallbackCount() == 0) {
       EXPECT_FALSE(IsSignalEnabled());
       if (timer_separate_) {
         EXPECT_TRUE(IsTimerEnabled());
       } else {
         EXPECT_FALSE(IsTimerEnabled());
       }
     }
   }
 
   // Verifies that the SIGPROF 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);
     // Check that the timer is disabled if shared, enabled otherwise.
     if (timer_separate_) {
       EXPECT_TRUE(IsTimerEnabled());
     } else {
       EXPECT_FALSE(IsTimerEnabled());
     }
     // Verify that the ProfileHandler is not accumulating profile ticks.
     uint64 interrupts_before = GetInterruptCount();
-    nanosleep(&sleep_interval, NULL);
+    usleep(kSleepInterval);
     uint64 interrupts_after = GetInterruptCount();
     EXPECT_EQ(interrupts_after, interrupts_before);
   }
 
   // Busy worker thread to accumulate cpu usage.
   BusyThread* busy_worker_;
 
  private:
   // The tests to run
   void RegisterUnregisterCallback();
@@ skipping 116 matching lines @@
   EXPECT_EQ(GetCallbackCount(), 1);
   EXPECT_TRUE(IsTimerEnabled());
   EXPECT_TRUE(IsSignalEnabled());
 }
 
 }  // namespace
 
 int main(int argc, char** argv) {
   return ProfileHandlerTest::RUN_ALL_TESTS();
 }