Initial GetSample implementation.

src/sampler.cc

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
-

[alph, 2014/09/17 11:55:43]

plz revert.

 #include "src/sampler.h"
 
 #if V8_OS_POSIX && !V8_OS_CYGWIN
 
 #define USE_SIGNALS
 
 #include <errno.h>
 #include <pthread.h>
 #include <signal.h>
 #include <sys/time.h>
@@ skipping 22 matching lines @@
 #endif
 
 #elif V8_OS_WIN || V8_OS_CYGWIN
 
 #include "src/base/win32-headers.h"
 
 #endif
 
 #include "src/v8.h"
 
+#include "src/base/logging.h"
 #include "src/base/platform/platform.h"
 #include "src/cpu-profiler-inl.h"
 #include "src/flags.h"
 #include "src/frames-inl.h"
 #include "src/log.h"
 #include "src/simulator.h"
 #include "src/v8threads.h"
 #include "src/vm-state-inl.h"
 
 
@@ skipping 205 matching lines @@
  private:
   Simulator* simulator_;
 };
 #endif  // USE_SIMULATOR
 
 
 #if defined(USE_SIGNALS)
 
 class SignalHandler : public AllStatic {
  public:
-  static void SetUp() { if (!mutex_) mutex_ = new base::Mutex(); }
-  static void TearDown() { delete mutex_; }
+  static void SetUp() {
+    if (mutex_ != NULL && sampling_semaphore_ != NULL)
+      return;                   // Already setup

[alph, 2014/09/17 11:55:42]

no need for the comment.

+
+    ASSERT_EQ(NULL, mutex_);
+    ASSERT_EQ(NULL, sampling_semaphore_);
+
+    mutex_ = new base::Mutex();
+    sampling_semaphore_ = new base::Semaphore(0);
+  }
+
+  static void TearDown() {
+    delete mutex_;
+    delete sampling_semaphore_;
+
+    mutex_ = NULL;
+    sampling_semaphore_ = NULL;
+  }
 
   static void IncreaseSamplerCount() {
     base::LockGuard<base::Mutex> lock_guard(mutex_);
     if (++client_count_ == 1) Install();
   }
 
   static void DecreaseSamplerCount() {
     base::LockGuard<base::Mutex> lock_guard(mutex_);
     if (--client_count_ == 0) Restore();
   }
@@ skipping 17 matching lines @@
   }
 
   static void Restore() {
     if (signal_handler_installed_) {
       sigaction(SIGPROF, &old_signal_handler_, 0);
       signal_handler_installed_ = false;
     }
   }
 
   static void HandleProfilerSignal(int signal, siginfo_t* info, void* context);
+
+  // The SIGPROF could have come from DoSample or from GetSample.
+  // GetSample is the internal endpoint for the public
+  // GetSample API, which aims to bypass all the internal buffers
+  // and return just one sample instead, rightaway.
+  //
+  // The origin of SIGPROF is determined by FLAG_new_sampler_api
+  //
+  // TODO(gholap): Eventually, get rid of DoSample.
+  //               Only GetSample should remain.
+  //               Then, get rid of FLAG_new_sampler_api too.
+
+  // This is the sample which will be filled by the call from GetSample.
+  static TickSample sample_;
+
+  // GetSample waits synchronously till the SIGPROF handler returns.
+  // this semaphore is used to signal GetSample.
+  static base::Semaphore* sampling_semaphore_;
+
+  // It is not that every time HandleProfilerSignal is invoked,
+  // it succeeds in obtaining a sample.
+  // This provides GetSample with the information whether
+  // the handler finished with or without getting the sample.
+  static bool sample_available_;
+
   // Protects the process wide state below.
   static base::Mutex* mutex_;
   static int client_count_;
   static bool signal_handler_installed_;
   static struct sigaction old_signal_handler_;
+
+  friend class Sampler;
 };
 
 
+TickSample SignalHandler::sample_;
+base::Semaphore* SignalHandler::sampling_semaphore_ = NULL;
+bool SignalHandler::sample_available_ = false;
+
 base::Mutex* SignalHandler::mutex_ = NULL;
 int SignalHandler::client_count_ = 0;
 struct sigaction SignalHandler::old_signal_handler_;
 bool SignalHandler::signal_handler_installed_ = false;
 
 
 void SignalHandler::HandleProfilerSignal(int signal, siginfo_t* info,
                                          void* context) {
 #if V8_OS_NACL
   // As Native Client does not support signal handling, profiling
   // is disabled.
   return;
 #else
+  // Even if we return prematurely,
+  // we need to signal the sampling_semaphore_
+  sample_available_ = false;
+  ScopedSemaphore scoped_semaphore(sampling_semaphore_);
+
   USE(info);
   if (signal != SIGPROF) return;
   Isolate* isolate = Isolate::UncheckedReentrantCurrent();
   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;
@@ skipping 117 matching lines @@
   state.pc = reinterpret_cast<Address>(mcontext.cpu.eip);
   state.sp = reinterpret_cast<Address>(mcontext.cpu.esp);
   state.fp = reinterpret_cast<Address>(mcontext.cpu.ebp);
 #elif V8_HOST_ARCH_ARM
   state.pc = reinterpret_cast<Address>(mcontext.cpu.gpr[ARM_REG_PC]);
   state.sp = reinterpret_cast<Address>(mcontext.cpu.gpr[ARM_REG_SP]);
   state.fp = reinterpret_cast<Address>(mcontext.cpu.gpr[ARM_REG_FP]);
 #endif  // V8_HOST_ARCH_*
 #endif  // V8_OS_QNX
 #endif  // USE_SIMULATOR
-  sampler->SampleStack(state);
+  if (FLAG_new_sampler_api) {
+    sample_.Init(sampler->isolate(), state);
+    sample_available_ = true;
+  } else {
+    sampler->SampleStack(state);
+  }
 #endif  // V8_OS_NACL
 }
 
 #endif
 
 
 class SamplerThread : public base::Thread {
  public:
   static const int kSamplerThreadStackSize = 64 * KB;
 
@@ skipping 82 matching lines @@
 
 //
 // StackTracer implementation
 //
 DISABLE_ASAN void TickSample::Init(Isolate* isolate,
                                    const RegisterState& regs) {
   ASSERT(isolate->IsInitialized());
   timestamp = base::TimeTicks::HighResolutionNow();
   pc = regs.pc;
   state = isolate->current_vm_state();
+  frames_count = 0;
 
   // Avoid collecting traces while doing GC.
   if (state == GC) return;
 
   Address js_entry_sp = isolate->js_entry_sp();
   if (js_entry_sp == 0) {
     // Not executing JS now.
     return;
   }
 
@@ skipping 32 matching lines @@
 
 
 void Sampler::TearDown() {
   SamplerThread::TearDown();
 #if defined(USE_SIGNALS)
   SignalHandler::TearDown();
 #endif
 }
 
 
+void Sampler::SetUpForNewSamplingAPI() {
+#if defined(USE_SIGNALS)
+  SignalHandler::SetUp();
+  if (!SignalHandler::Installed())
+    SignalHandler::Install();
+#endif
+    // Nothing needs to be done for windows.
+}
+
+
 Sampler::Sampler(Isolate* isolate, int interval)
     : isolate_(isolate),
       interval_(interval),
       profiling_(false),
       has_processing_thread_(false),
       active_(false),
       is_counting_samples_(false),
       js_and_external_sample_count_(0) {
   data_ = new PlatformData;
 }
@@ skipping 52 matching lines @@
 }
 
 
 #if defined(USE_SIGNALS)
 
 void Sampler::DoSample() {
   if (!SignalHandler::Installed()) return;
   pthread_kill(platform_data()->vm_tid(), SIGPROF);
 }
 
+
+void Sampler::GetSample(v8::Sample* sample) {
+  SignalHandler::sampling_semaphore_->Wait();
+  if (SignalHandler::sample_available_) {
+    sample = new(sample) v8::Sample(
+      &SignalHandler::sample_.stack[0],
+      &SignalHandler::sample_.stack[SignalHandler::sample_.frames_count]);
+  }
+  else {
+    sample = new(sample) v8::Sample();
+  }
+}
+
 #elif V8_OS_WIN || V8_OS_CYGWIN
 
+#if V8_HOST_ARCH_X64
+#define CONTEXT_TO_STATE(context, state)             \
+  state.pc = reinterpret_cast<Address>(context.Rip); \
+  state.sp = reinterpret_cast<Address>(context.Rsp); \
+  state.fp = reinterpret_cast<Address>(context.Rbp)
+#else
+#define CONTEXT_TO_STATE(context, state)             \
+  state.pc = reinterpret_cast<Address>(context.Eip); \
+  state.sp = reinterpret_cast<Address>(context.Esp); \
+  state.fp = reinterpret_cast<Address>(context.Ebp)
+#endif
+
+
 void Sampler::DoSample() {
   HANDLE profiled_thread = platform_data()->profiled_thread();
   if (profiled_thread == NULL) return;
 
 #if defined(USE_SIMULATOR)
   SimulatorHelper helper;
   if (!helper.Init(this, isolate())) return;
 #endif
 
   const DWORD kSuspendFailed = static_cast<DWORD>(-1);
   if (SuspendThread(profiled_thread) == kSuspendFailed) return;
 
   // Context used for sampling the register state of the profiled thread.
   CONTEXT context;
   memset(&context, 0, sizeof(context));
   context.ContextFlags = CONTEXT_FULL;
   if (GetThreadContext(profiled_thread, &context) != 0) {
     RegisterState state;
 #if defined(USE_SIMULATOR)
     helper.FillRegisters(&state);
 #else
-#if V8_HOST_ARCH_X64
-    state.pc = reinterpret_cast<Address>(context.Rip);
-    state.sp = reinterpret_cast<Address>(context.Rsp);
-    state.fp = reinterpret_cast<Address>(context.Rbp);
-#else
-    state.pc = reinterpret_cast<Address>(context.Eip);
-    state.sp = reinterpret_cast<Address>(context.Esp);
-    state.fp = reinterpret_cast<Address>(context.Ebp);
-#endif
+    CONTEXT_TO_STATE(context, state);
 #endif  // USE_SIMULATOR
     SampleStack(state);
   }
   ResumeThread(profiled_thread);
 }
 
+
+void Sampler::GetSample(Isolate* isolate,
+                        const CONTEXT& context,
+                        v8::Sample* sample) {
+  TickSample tick_sample;
+  RegisterState state;
+  CONTEXT_TO_STATE(context, state);
+  tick_sample.Init(isolate, state);
+  sample = new(sample) v8::Sample(&tick_sample.stack[0],
+                                  &tick_sample.stack[tick_sample.frames_count]);
+}
+
 #endif  // USE_SIGNALS
 
 
 } }  // namespace v8::internal