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.
 
 #include "src/sampler.h"
 
 #if V8_OS_POSIX && !V8_OS_CYGWIN
 
 #define USE_SIGNALS
 
@@ skipping 24 matching lines @@
     !defined(__BIONIC_HAVE_STRUCT_SIGCONTEXT)
 #include <asm/sigcontext.h>  // NOLINT
 #endif
 
 #elif V8_OS_WIN || V8_OS_CYGWIN
 
 #include "src/base/win32-headers.h"
 
 #endif
 
+#include "include/v8-sampler.h"
+
 #include "src/v8.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 207 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_) mutex_ = new base::Mutex();
+    if (!register_state_semaphore_)
+      register_state_semaphore_ = new base::Semaphore(0);
+  }
+
+  static void TearDown() {
+    delete mutex_;
+    delete register_state_semaphore_;
+  }
 
   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();
   }
 
   static bool Installed() {
     return signal_handler_installed_;
   }
 
+  static RegisterState GetRegisterState() {
+    register_state_semaphore_->Wait();
+    register_state_updated_ = false;
+    return register_state_;
+  }
+
+  static bool WasRegisterStateUpdated() {
+    return register_state_updated_;
+  }
+
+
  private:
   static void Install() {
     struct sigaction sa;
     sa.sa_sigaction = &HandleProfilerSignal;
     sigemptyset(&sa.sa_mask);
 #if V8_OS_QNX
     sa.sa_flags = SA_SIGINFO;
 #else
     sa.sa_flags = SA_RESTART | SA_SIGINFO;
 #endif
     signal_handler_installed_ =
         (sigaction(SIGPROF, &sa, &old_signal_handler_) == 0);
   }
 
   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);
+
+  // HandleProfilerSignal puts the state of registers into
+  // register_state_ and then signals on the semaphore,
+  // so that DoSample can use it.
+  static base::Semaphore* register_state_semaphore_;
+  static RegisterState register_state_;
+  // It is not that every time HandleProfilerSignal is invoked,
+  // the register state is guarenteed to be updated.
+  // This provides the SIGPROF sender with the information whether
+  // the handler finished with or without updating the register state.
+  static bool register_state_updated_;
+
   // 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_;
 };
 
 
 base::Mutex* SignalHandler::mutex_ = NULL;
 int SignalHandler::client_count_ = 0;
 struct sigaction SignalHandler::old_signal_handler_;
 bool SignalHandler::signal_handler_installed_ = false;
 
+base::Semaphore* SignalHandler::register_state_semaphore_ = NULL;
+RegisterState SignalHandler::register_state_;
+bool SignalHandler::register_state_updated_ = 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
   USE(info);
   if (signal != SIGPROF) return;
@@ skipping 125 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);
+  register_state_ = state;
+  register_state_updated_ = true;
+  register_state_semaphore_->Signal();
 #endif  // V8_OS_NACL
 }
 
 #endif
 
 
 class SamplerThread : public base::Thread {
  public:
   static const int kSamplerThreadStackSize = 64 * KB;
 
@@ skipping 77 matching lines @@
 
 
 base::Mutex* SamplerThread::mutex_ = NULL;
 SamplerThread* SamplerThread::instance_ = NULL;
 
 
 //
 // StackTracer implementation
 //
 DISABLE_ASAN void TickSample::Init(Isolate* isolate,
-                                   const RegisterState& regs) {
+                                   const RegisterState& regs,
+                                   unsigned max_frame_count) {
   ASSERT(isolate->IsInitialized());
   timestamp = base::TimeTicks::HighResolutionNow();
   pc = regs.pc;
   state = isolate->current_vm_state();
 
   // Avoid collecting traces while doing GC.
   if (state == GC) return;
 
   Address js_entry_sp = isolate->js_entry_sp();
   if (js_entry_sp == 0) {
@@ skipping 12 matching lines @@
   } else {
     // Sample potential return address value for frameless invocation of
     // stubs (we'll figure out later, if this value makes sense).
     tos = Memory::Address_at(regs.sp);
     has_external_callback = false;
   }
 
   SafeStackFrameIterator it(isolate, regs.fp, regs.sp, js_entry_sp);
   top_frame_type = it.top_frame_type();
   unsigned i = 0;
-  while (!it.done() && i < TickSample::kMaxFramesCount) {
+  if (max_frame_count > kMaxFramesCount)
+    max_frame_count = kMaxFramesCount;
+  while (!it.done() && i < max_frame_count) {
     stack[i++] = it.frame()->pc();
     it.Advance();
   }
   frames_count = i;
 }
 
 
 void Sampler::SetUp() {
 #if defined(USE_SIGNALS)
   SignalHandler::SetUp();
@@ skipping 70 matching lines @@
   }
   Tick(sample);
   if (sample != &sample_obj) {
     isolate_->cpu_profiler()->FinishTickSample();
   }
 }
 
 
 #if defined(USE_SIGNALS)
 
-void Sampler::DoSample() {
+void Sampler::CaptureRegisterState_() {
   if (!SignalHandler::Installed()) return;
   pthread_kill(platform_data()->vm_tid(), SIGPROF);
 }
 
+
+void Sampler::DoSample() {
+  CaptureRegisterState_();
+  if (SignalHandler::WasRegisterStateUpdated())
+    SampleStack(SignalHandler::GetRegisterState());
+}
+
+
+void Sampler::GetSample(TickSample* sample, unsigned max_frame_count) {
+  CaptureRegisterState_();
+  if (SignalHandler::WasRegisterStateUpdated())
+    sample->Init(isolate_,
+                 SignalHandler::GetRegisterState(),
+                 max_frame_count);
+}
+
 #elif V8_OS_WIN || V8_OS_CYGWIN
 
-void Sampler::DoSample() {
+void Sampler::CaptureRegisterState_(RegisterState* state,
+                                    bool* captured_successfully) {
+  *captured_successfully = false;
+
   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);
+    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);
+    state->pc = reinterpret_cast<Address>(context.Eip);
+    state->sp = reinterpret_cast<Address>(context.Esp);
+    state->fp = reinterpret_cast<Address>(context.Ebp);
 #endif
 #endif  // USE_SIMULATOR
-    SampleStack(state);
+    *captured_successfully = true;
   }
   ResumeThread(profiled_thread);
 }
 
+
+void Sampler::DoSample() {
+  bool register_state_captured;
+  RegisterState state;
+  CaptureRegisterState_(state, register_state_captured);
+  if (register_state_captured) SampleStack(state);
+}
+
+
+void Sampler::GetSample(TickSample* sample, unsigned max_frame_count) {
+  bool register_state_captured;
+  RegisterState state;
+  CaptureRegisterState_(state, register_state_captured);
+  if (register_state_captured)
+    sample->Init(isolate_, state, max_frame_count);
+}
+
 #endif  // USE_SIGNALS
 
 
 } }  // namespace v8::internal