Perform CPU sampling by CPU sampling thread only iff processing thread is not running.

src/platform-linux.cc

 // Copyright 2012 the V8 project authors. 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
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 1007 matching lines @@
 #else
   // Glibc doesn't provide a wrapper for gettid(2).
   return syscall(SYS_gettid);
 #endif
 }
 
 
 static void ProfilerSignalHandler(int signal, siginfo_t* info, void* context) {
   USE(info);
   if (signal != SIGPROF) return;
+
   Isolate* isolate = Isolate::UncheckedCurrent();
   if (isolate == NULL || !isolate->IsInitialized() || !isolate->IsInUse()) {
     // We require a fully initialized and entered isolate.
     return;
   }
   if (v8::Locker::IsActive() &&
       !isolate->thread_manager()->IsLockedByCurrentThread()) {
     return;
   }
 
   Sampler* sampler = isolate->logger()->sampler();
   if (sampler == NULL || !sampler->IsActive()) return;
 
+  TickSample sample_obj;
   TickSample* sample = CpuProfiler::StartTickSampleEvent(isolate);
-  if (sample == NULL) return;
+  if (sample == NULL) sample = &sample_obj;
 
   // Extracting the sample from the context is extremely machine dependent.
   ucontext_t* ucontext = reinterpret_cast<ucontext_t*>(context);
   mcontext_t& mcontext = ucontext->uc_mcontext;
   sample->state = isolate->current_vm_state();
 #if V8_HOST_ARCH_IA32
   sample->pc = reinterpret_cast<Address>(mcontext.gregs[REG_EIP]);
   sample->sp = reinterpret_cast<Address>(mcontext.gregs[REG_ESP]);
   sample->fp = reinterpret_cast<Address>(mcontext.gregs[REG_EBP]);
 #elif V8_HOST_ARCH_X64
@@ skipping 130 matching lines @@
       delete instance_;
       instance_ = NULL;
     }
   }
 
   // Implement Thread::Run().
   virtual void Run() {
     SamplerRegistry::State state;
     while ((state = SamplerRegistry::GetState()) !=
            SamplerRegistry::HAS_NO_SAMPLERS) {
-      if (rate_limiter_.SuspendIfNecessary()) continue;
-      if (RuntimeProfiler::IsEnabled()) {
+      bool cpu_profiling_enabled =
+          (state == SamplerRegistry::HAS_CPU_PROFILING_SAMPLERS);
+      bool runtime_profiler_enabled = RuntimeProfiler::IsEnabled();
+      // When CPU profiling is enabled both JavaScript and C++ code is
+      // profiled. We must not suspend.
+      if (!cpu_profiling_enabled) {
+        if (rate_limiter_.SuspendIfNecessary()) continue;
+      }
+      if (cpu_profiling_enabled && runtime_profiler_enabled) {
+        if (!SamplerRegistry::IterateActiveSamplers(&DoCpuProfile, NULL)) {
+          return;
+        }
+        Sleep(HALF_INTERVAL);
         if (!SamplerRegistry::IterateActiveSamplers(&DoRuntimeProfile, NULL)) {
           return;
         }
+        Sleep(HALF_INTERVAL);
+      } else {
+        if (cpu_profiling_enabled) {
+          if (!SamplerRegistry::IterateActiveSamplers(&DoCpuProfile, NULL)) {
+            return;
+          }
+        }
+        if (runtime_profiler_enabled) {
+          if (!SamplerRegistry::IterateActiveSamplers(&DoRuntimeProfile,
+                                                      NULL)) {
+            return;
+          }
+        }
+        Sleep(FULL_INTERVAL);
       }
-      Sleep(FULL_INTERVAL);
     }
   }
 
+  static void DoCpuProfile(Sampler* sampler, void*) {
+    if (!sampler->IsProfiling()) return;
+    sampler->platform_data()->SendProfilingSignal();
+  }
+
   static void DoRuntimeProfile(Sampler* sampler, void* ignored) {
     if (!sampler->isolate()->IsInitialized()) return;
     sampler->isolate()->runtime_profiler()->NotifyTick();
   }
 
   void Sleep(SleepInterval full_or_half) {
     // Convert ms to us and subtract 100 us to compensate delays
     // occuring during signal delivery.
     useconds_t interval = interval_ * 1000 - 100;
     if (full_or_half == HALF_INTERVAL) interval /= 2;
@@ skipping 64 matching lines @@
   CpuProfilerSignalHandler::TearDown();
   delete limit_mutex;
 }
 
 
 Sampler::Sampler(Isolate* isolate, int interval)
     : isolate_(isolate),
       interval_(interval),
       profiling_(false),
       active_(false),
+      has_processing_thread_(false),
       samples_taken_(0) {
   data_ = new PlatformData;
 }
 
 
 Sampler::~Sampler() {
   ASSERT(!IsActive());
   delete data_;
 }
 
 
 void Sampler::DoSample() {
   platform_data()->SendProfilingSignal();
 }
 
 
 void Sampler::Start() {
   ASSERT(!IsActive());
-  CpuProfilerSignalHandler::InstallSignalHandler();
   SetActive(true);
   SignalSender::AddActiveSampler(this);
 }
 
 
 void Sampler::Stop() {
   ASSERT(IsActive());
-  CpuProfilerSignalHandler::RestoreSignalHandler();
   SignalSender::RemoveActiveSampler(this);
   SetActive(false);
 }
 
 
+void Sampler::StartSampling() {
+  CpuProfilerSignalHandler::InstallSignalHandler();
+}
+
+
+void Sampler::StopSampling() {
+  CpuProfilerSignalHandler::RestoreSignalHandler();
+}
+
+
 } }  // namespace v8::internal