V8 Sampling Profiler: Support sampling on Windows.

content/renderer/devtools/v8_sampling_profiler.cc

 // Copyright 2014 The Chromium 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 "content/renderer/devtools/v8_sampling_profiler.h"
 
 #if defined(OS_POSIX)
 #include <signal.h>
 #define USE_SIGNALS
 #endif
 
 #include "base/format_macros.h"
 #include "base/strings/stringprintf.h"
 #include "base/synchronization/cancellation_flag.h"
 #include "base/threading/platform_thread.h"
 #include "base/trace_event/trace_event.h"
 #include "base/trace_event/trace_event_argument.h"
+#if defined(OS_WIN)
+#include "base/win/scoped_handle.h"

[yurys, 2015/03/24 14:15:25]

Please minimize number of dependencies on base/ and other Chromium-specific code
so that we can later easily extract profiler implementation into a separate
component. Can be done in a separate change.

[alph, 2015/03/24 14:17:08]

Acknowledged.

+#endif
 #include "content/renderer/devtools/lock_free_circular_queue.h"
 #include "content/renderer/render_thread_impl.h"
 #include "v8/include/v8.h"
 
 using base::trace_event::ConvertableToTraceFormat;
 using base::trace_event::TraceLog;
 using base::trace_event::TracedValue;
 using v8::Isolate;
 
 namespace content {
 
 namespace {
 
+#if defined(OS_WIN)
+typedef base::win::ScopedHandle UniversalThreadHandle;
+#else
+typedef base::PlatformThreadHandle UniversalThreadHandle;
+#endif
+
 std::string PtrToString(const void* value) {
   return base::StringPrintf(
       "0x%" PRIx64, static_cast<uint64>(reinterpret_cast<intptr_t>(value)));
 }
 
 class SampleRecord {
  public:
   static const int kMaxFramesCountLog2 = 8;
   static const unsigned kMaxFramesCount = (1u << kMaxFramesCountLog2) - 1;
 
@@ skipping 88 matching lines @@
                sample_events_to_collect_for_test_;
   }
 
  private:
   Sampler();
 
   static void InstallJitCodeEventHandler(Isolate* isolate, void* data);
   static void HandleJitCodeEvent(const v8::JitCodeEvent* event);
   static scoped_refptr<ConvertableToTraceFormat> JitCodeEventToTraceFormat(
       const v8::JitCodeEvent* event);
-  static base::PlatformThreadHandle GetCurrentThreadHandle();
+  static UniversalThreadHandle GetCurrentThreadHandle();
 
   void InjectPendingEvents();
 
   static const unsigned kNumberOfSamples = 10;
   typedef LockFreeCircularQueue<SampleRecord, kNumberOfSamples> SamplingQueue;
 
   base::PlatformThreadId thread_id_;
-  base::PlatformThreadHandle thread_handle_;
+  UniversalThreadHandle thread_handle_;
   Isolate* isolate_;
   scoped_ptr<SamplingQueue> samples_data_;
   base::subtle::Atomic32 code_added_events_count_;
   base::subtle::Atomic32 samples_count_;
   int code_added_events_to_collect_for_test_;
   int sample_events_to_collect_for_test_;
 
   static base::LazyInstance<base::ThreadLocalPointer<Sampler>>::Leaky
       tls_instance_;
 };
@@ skipping 18 matching lines @@
   DCHECK(GetInstance());
   tls_instance_.Pointer()->Set(nullptr);
 }
 
 // static
 scoped_ptr<Sampler> Sampler::CreateForCurrentThread() {
   return scoped_ptr<Sampler>(new Sampler());
 }
 
 // static
-base::PlatformThreadHandle Sampler::GetCurrentThreadHandle() {
+UniversalThreadHandle Sampler::GetCurrentThreadHandle() {
 #ifdef OS_WIN
-  // TODO(alph): Add Windows support.
-  return base::PlatformThreadHandle();
+  return base::win::ScopedHandle(::OpenThread(
+      THREAD_GET_CONTEXT | THREAD_SUSPEND_RESUME | THREAD_QUERY_INFORMATION,
+      false, base::PlatformThread::CurrentId()));
 #else
   return base::PlatformThread::CurrentHandle();
 #endif
 }
 
 void Sampler::Start() {
   samples_data_.reset(new SamplingQueue());
   v8::JitCodeEventHandler handler = &HandleJitCodeEvent;
   isolate_->RequestInterrupt(&InstallJitCodeEventHandler,
                              reinterpret_cast<void*>(handler));
 }
 
 void Sampler::Stop() {
   isolate_->RequestInterrupt(&InstallJitCodeEventHandler, nullptr);
   samples_data_.reset();
 }
 
+#if ARCH_CPU_64_BITS
+#define REG_64_32(reg64, reg32) reg64
+#else
+#define REG_64_32(reg64, reg32) reg32
+#endif  // ARCH_CPU_64_BITS
+
 void Sampler::Sample() {
-#if defined(USE_SIGNALS)
+#if defined(OS_WIN)
+  const DWORD kSuspendFailed = static_cast<DWORD>(-1);
+  if (::SuspendThread(thread_handle_.Get()) == kSuspendFailed)
+    return;
+  CONTEXT context;
+  memset(&context, 0, sizeof(context));
+  context.ContextFlags = CONTEXT_FULL;
+  if (::GetThreadContext(thread_handle_.Get(), &context) != 0) {
+    v8::RegisterState state;
+    state.pc = reinterpret_cast<void*>(context.REG_64_32(Rip, Eip));
+    state.sp = reinterpret_cast<void*>(context.REG_64_32(Rsp, Esp));
+    state.fp = reinterpret_cast<void*>(context.REG_64_32(Rbp, Ebp));
+    // TODO(alph): It is not needed to buffer the events on Windows.
+    // We can just collect and fire trace event right away.
+    DoSample(state);
+  }
+  ::ResumeThread(thread_handle_.Get());
+#elif defined(USE_SIGNALS)
   int error = pthread_kill(thread_handle_.platform_handle(), SIGPROF);
   if (error) {
     LOG(ERROR) << "pthread_kill failed with error " << error << " "
                << strerror(error);
   }
+#endif
   InjectPendingEvents();
-#endif
 }
 
 void Sampler::DoSample(const v8::RegisterState& state) {
   // Called in the sampled thread signal handler.
   // Because of that it is not allowed to do any memory allocation here.
   base::TimeTicks timestamp = base::TimeTicks::NowFromSystemTraceTime();
   SampleRecord* record = samples_data_->StartEnqueue();
   if (!record)
     return;
   record->Collect(isolate_, timestamp, state);
@@ skipping 224 matching lines @@
 void V8SamplingThread::HandleProfilerSignal(int signal,
                                             siginfo_t* info,
                                             void* context) {
   if (signal != SIGPROF)
     return;
   ucontext_t* ucontext = reinterpret_cast<ucontext_t*>(context);
   mcontext_t& mcontext = ucontext->uc_mcontext;
   v8::RegisterState state;
 
 #if defined(ARCH_CPU_ARM_FAMILY)
-
-#if ARCH_CPU_64_BITS
-  state.pc = reinterpret_cast<void*>(mcontext.pc);
-  state.sp = reinterpret_cast<void*>(mcontext.sp);
-  state.fp = reinterpret_cast<void*>(mcontext.regs[29]);
-#elif ARCH_CPU_32_BITS
-  state.pc = reinterpret_cast<void*>(mcontext.arm_pc);
-  state.sp = reinterpret_cast<void*>(mcontext.arm_sp);
-  state.fp = reinterpret_cast<void*>(mcontext.arm_fp);
-#endif  // ARCH_CPU_32_BITS
+  state.pc = reinterpret_cast<void*>(mcontext.REG_64_32(pc, arm_pc));
+  state.sp = reinterpret_cast<void*>(mcontext.REG_64_32(sp, arm_sp));
+  state.fp = reinterpret_cast<void*>(mcontext.REG_64_32(regs[29], arm_fp));
 
 #elif defined(ARCH_CPU_X86_FAMILY)
-
 #if defined(OS_MACOSX)
-#if ARCH_CPU_64_BITS
-  state.pc = reinterpret_cast<void*>(mcontext->__ss.__rip);
-  state.sp = reinterpret_cast<void*>(mcontext->__ss.__rsp);
-  state.fp = reinterpret_cast<void*>(mcontext->__ss.__rbp);
-#elif ARCH_CPU_32_BITS
-  state.pc = reinterpret_cast<void*>(mcontext->__ss.__eip);
-  state.sp = reinterpret_cast<void*>(mcontext->__ss.__esp);
-  state.fp = reinterpret_cast<void*>(mcontext->__ss.__ebp);
-#endif  // ARCH_CPU_32_BITS
-
+  state.pc = reinterpret_cast<void*>(mcontext->__ss.REG_64_32(__rip, __eip));
+  state.sp = reinterpret_cast<void*>(mcontext->__ss.REG_64_32(__rsp, __esp));
+  state.fp = reinterpret_cast<void*>(mcontext->__ss.REG_64_32(__rbp, __ebp));
 #else
-#if ARCH_CPU_64_BITS
-  state.pc = reinterpret_cast<void*>(mcontext.gregs[REG_RIP]);
-  state.sp = reinterpret_cast<void*>(mcontext.gregs[REG_RSP]);
-  state.fp = reinterpret_cast<void*>(mcontext.gregs[REG_RBP]);
-#elif ARCH_CPU_32_BITS
-  state.pc = reinterpret_cast<void*>(mcontext.gregs[REG_EIP]);
-  state.sp = reinterpret_cast<void*>(mcontext.gregs[REG_ESP]);
-  state.fp = reinterpret_cast<void*>(mcontext.gregs[REG_EBP]);
-#endif  // ARCH_CPU_32_BITS
+  state.pc =
+      reinterpret_cast<void*>(mcontext.gregs[REG_64_32(REG_RIP, REG_EIP)]);
+  state.sp =
+      reinterpret_cast<void*>(mcontext.gregs[REG_64_32(REG_RSP, REG_ESP)]);
+  state.fp =
+      reinterpret_cast<void*>(mcontext.gregs[REG_64_32(REG_RBP, REG_EBP)]);
 #endif  // OS_MACOS
 #endif  // ARCH_CPU_X86_FAMILY
 
   Sampler::GetInstance()->DoSample(state);
 }
 #endif
 
 void V8SamplingThread::Start() {
   if (!base::PlatformThread::Create(0, this, &sampling_thread_handle_)) {
     DCHECK(false) << "failed to create sampling thread";
@@ skipping 60 matching lines @@
   render_thread_sampler_->SetEventsToCollectForTest(code_added_events,
                                                     sample_events);
   waitable_event_for_testing_.reset(new base::WaitableEvent(false, false));
 }
 
 void V8SamplingProfiler::WaitSamplingEventForTesting() {
   waitable_event_for_testing_->Wait();
 }
 
 }  // namespace blink