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

third_party/tcmalloc/chromium/src/profile-handler.cc

 // Copyright (c) 2009, Google Inc.
 // All rights reserved.
 // 
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 // 
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
@@ skipping 71 matching lines @@
   //
   // Prior to determining whether timers are shared, this function will
   // unconditionally start the timer.  However, if this function determines
   // that timers are shared, then it will stop the timer if no callbacks are
   // currently registered.
   void RegisterThread();
 
   // Registers a callback routine to receive profile timer ticks. The returned
   // token is to be used when unregistering this callback and must not be
   // deleted by the caller. Registration of the first callback enables the
-  // SIGPROF handler.
+  // SIGPROF handler (or SIGALRM if using ITIMER_REAL).
   ProfileHandlerToken* RegisterCallback(ProfileHandlerCallback callback,
                                         void* callback_arg);
 
   // Unregisters a previously registered callback. Expects the token returned
   // by the corresponding RegisterCallback routine. Unregistering the last
-  // callback disables the SIGPROF handler.
+  // callback disables the SIGPROF handler (or SIGALRM if using ITIMER_REAL).
   void UnregisterCallback(ProfileHandlerToken* token)
       NO_THREAD_SAFETY_ANALYSIS;
 
   // Unregisters all the callbacks, stops the timer if shared, disables the
-  // SIGPROF handler and clears the timer_sharing_ state.
+  // SIGPROF (or SIGALRM) handler and clears the timer_sharing_ state.
   void Reset();
 
   // Gets the current state of profile handler.
   void GetState(ProfileHandlerState* state);
 
   // Initializes and returns the ProfileHandler singleton.
   static ProfileHandler* Instance();
 
  private:
   ProfileHandler();
   ~ProfileHandler();
 
   // Largest allowed frequency.
   static const int32 kMaxFrequency = 4000;
   // Default frequency.
   static const int32 kDefaultFrequency = 100;
 
   // ProfileHandler singleton.
   static ProfileHandler* instance_;
 
   // pthread_once_t for one time initialization of ProfileHandler singleton.
   static pthread_once_t once_;
 
   // Initializes the ProfileHandler singleton via GoogleOnceInit.
   static void Init();
 
-  // Counts the number of SIGPROF interrupts received.
+  // The number of SIGPROF (or SIGALRM for ITIMER_REAL) interrupts received.
   int64 interrupts_ GUARDED_BY(signal_lock_);
 
-  // SIGPROF interrupt frequency, read-only after construction.
+  // SIGPROF/SIGALRM interrupt frequency, read-only after construction.
   int32 frequency_;
 
+  // ITIMER_PROF (which uses SIGPROF), or ITIMER_REAL (which uses SIGALRM)
+  int timer_type_;
+
   // Counts the number of callbacks registered.
   int32 callback_count_ GUARDED_BY(control_lock_);
 
   // Whether or not the threading system provides interval timers that are
   // shared by all threads in a process.
   enum {
     // No timer initialization attempted yet.
     TIMERS_UNTOUCHED,
     // First thread has registered and set timer.
     TIMERS_ONE_SET,
@@ skipping 43 matching lines @@
   // thread.  This actually checks the kernel's interval timer setting.  (It is
   // used to detect whether timers are shared or separate.)
   bool IsTimerRunning() EXCLUSIVE_LOCKS_REQUIRED(control_lock_);
 
   // Sets the timer interrupt signal handler.
   void EnableHandler() EXCLUSIVE_LOCKS_REQUIRED(control_lock_);
 
   // Disables (ignores) the timer interrupt signal.
   void DisableHandler() EXCLUSIVE_LOCKS_REQUIRED(control_lock_);
 
-  // SIGPROF handler. Iterate over and call all the registered callbacks.
+  // SIGPROF/SIGALRM handler. Iterate over and call all the registered callbacks.
   static void SignalHandler(int sig, siginfo_t* sinfo, void* ucontext);
 
-  DISALLOW_EVIL_CONSTRUCTORS(ProfileHandler);
+  DISALLOW_COPY_AND_ASSIGN(ProfileHandler);
 };
 
 ProfileHandler* ProfileHandler::instance_ = NULL;
 pthread_once_t ProfileHandler::once_ = PTHREAD_ONCE_INIT;
 
 const int32 ProfileHandler::kMaxFrequency;
 const int32 ProfileHandler::kDefaultFrequency;
 
 // If we are LD_PRELOAD-ed against a non-pthreads app, then
 // pthread_once won't be defined.  We declare it here, for that
@@ skipping 21 matching lines @@
     assert(instance_ != NULL);
   }
   return instance_;
 }
 
 ProfileHandler::ProfileHandler()
     : interrupts_(0),
       callback_count_(0),
       timer_sharing_(TIMERS_UNTOUCHED) {
   SpinLockHolder cl(&control_lock_);
+
+  timer_type_ = (getenv("CPUPROFILE_REALTIME") ? ITIMER_REAL : ITIMER_PROF);
+
   // Get frequency of interrupts (if specified)
   char junk;
   const char* fr = getenv("CPUPROFILE_FREQUENCY");
   if (fr != NULL && (sscanf(fr, "%u%c", &frequency_, &junk) == 1) &&
       (frequency_ > 0)) {
     // Limit to kMaxFrequency
     frequency_ = (frequency_ > kMaxFrequency) ? kMaxFrequency : frequency_;
   } else {
     frequency_ = kDefaultFrequency;
   }
@@ skipping 129 matching lines @@
   }
   state->frequency = frequency_;
   state->callback_count = callback_count_;
 }
 
 void ProfileHandler::StartTimer() {
   struct itimerval timer;
   timer.it_interval.tv_sec = 0;
   timer.it_interval.tv_usec = 1000000 / frequency_;
   timer.it_value = timer.it_interval;
-  setitimer(ITIMER_PROF, &timer, 0);
+  setitimer(timer_type_, &timer, 0);
 }
 
 void ProfileHandler::StopTimer() {
   struct itimerval timer;
   memset(&timer, 0, sizeof timer);
-  setitimer(ITIMER_PROF, &timer, 0);
+  setitimer(timer_type_, &timer, 0);
 }
 
 bool ProfileHandler::IsTimerRunning() {
   struct itimerval current_timer;
-  RAW_CHECK(0 == getitimer(ITIMER_PROF, &current_timer), "getitimer");
+  RAW_CHECK(0 == getitimer(timer_type_, &current_timer), "getitimer");
   return (current_timer.it_value.tv_sec != 0 ||
           current_timer.it_value.tv_usec != 0);
 }
 
 void ProfileHandler::EnableHandler() {
   struct sigaction sa;
   sa.sa_sigaction = SignalHandler;
   sa.sa_flags = SA_RESTART | SA_SIGINFO;
   sigemptyset(&sa.sa_mask);
-  RAW_CHECK(sigaction(SIGPROF, &sa, NULL) == 0, "sigprof (enable)");
+  const int signal_number = (timer_type_ == ITIMER_PROF ? SIGPROF : SIGALRM);
+  RAW_CHECK(sigaction(signal_number, &sa, NULL) == 0, "sigprof (enable)");
 }
 
 void ProfileHandler::DisableHandler() {
   struct sigaction sa;
   sa.sa_handler = SIG_IGN;
   sa.sa_flags = SA_RESTART;
   sigemptyset(&sa.sa_mask);
-  RAW_CHECK(sigaction(SIGPROF, &sa, NULL) == 0, "sigprof (disable)");
+  const int signal_number = (timer_type_ == ITIMER_PROF ? SIGPROF : SIGALRM);
+  RAW_CHECK(sigaction(signal_number, &sa, NULL) == 0, "sigprof (disable)");
 }
 
 void ProfileHandler::SignalHandler(int sig, siginfo_t* sinfo, void* ucontext) {
   int saved_errno = errno;
   RAW_CHECK(instance_ != NULL, "ProfileHandler is not initialized");
   {
     SpinLockHolder sl(&instance_->signal_lock_);
     ++instance_->interrupts_;
     for (CallbackIterator it = instance_->callbacks_.begin();
          it != instance_->callbacks_.end();
          ++it) {
       (*it)->callback(sig, sinfo, ucontext, (*it)->callback_arg);
     }
   }
   errno = saved_errno;
 }
 
 // The sole purpose of this class is to initialize the ProfileHandler singleton
 // when the global static objects are created. Note that the main thread will
 // be registered at this time.
 class ProfileHandlerInitializer {
  public:
   ProfileHandlerInitializer() {
     ProfileHandler::Instance()->RegisterThread();
   }
 
  private:
-  DISALLOW_EVIL_CONSTRUCTORS(ProfileHandlerInitializer);
+  DISALLOW_COPY_AND_ASSIGN(ProfileHandlerInitializer);
 };
 // ProfileHandlerInitializer singleton
 static ProfileHandlerInitializer profile_handler_initializer;
 
 extern "C" void ProfileHandlerRegisterThread() {
   ProfileHandler::Instance()->RegisterThread();
 }
 
 extern "C" ProfileHandlerToken* ProfileHandlerRegisterCallback(
     ProfileHandlerCallback callback, void* callback_arg) {
@@ skipping 29 matching lines @@
 extern "C" void ProfileHandlerUnregisterCallback(ProfileHandlerToken* token) {
 }
 
 extern "C" void ProfileHandlerReset() {
 }
 
 extern "C" void ProfileHandlerGetState(ProfileHandlerState* state) {
 }
 
 #endif  // OS_CYGWIN