Revert of Create libsampler as V8 sampler library.

src/log.cc

 // Copyright 2011 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/log.h"
 
 #include <cstdarg>
 #include <sstream>
 
 #include "src/bailout-reason.h"
 #include "src/base/platform/platform.h"
 #include "src/bootstrapper.h"
 #include "src/code-stubs.h"
 #include "src/deoptimizer.h"
 #include "src/global-handles.h"
 #include "src/interpreter/bytecodes.h"
 #include "src/interpreter/interpreter.h"
-#include "src/libsampler/v8-sampler.h"
 #include "src/log-inl.h"
 #include "src/log-utils.h"
 #include "src/macro-assembler.h"
 #include "src/perf-jit.h"
-#include "src/profiler/cpu-profiler-inl.h"
+#include "src/profiler/cpu-profiler.h"
 #include "src/runtime-profiler.h"
 #include "src/string-stream.h"
 #include "src/vm-state-inl.h"
 
 namespace v8 {
 namespace internal {
 
 
 #define DECLARE_EVENT(ignore1, name) name,
 static const char* const kLogEventsNames[Logger::NUMBER_OF_LOG_EVENTS] = {
@@ skipping 499 matching lines @@
   JitCodeEvent event;
   memset(&event, 0, sizeof(event));
   event.type = JitCodeEvent::CODE_END_LINE_INFO_RECORDING;
   event.code_start = code->instruction_start();
   event.user_data = jit_handler_data;
 
   code_event_handler_(&event);
 }
 
 
-// TODO(lpy): Keeping sampling thread inside V8 is a workaround currently,
-// the reason is to reduce code duplication during migration to sampler library,
-// sampling thread, as well as the sampler, will be moved to D8 eventually.
-class SamplingThread : public base::Thread {
- public:
-  static const int kSamplingThreadStackSize = 64 * KB;
-
-  SamplingThread(sampler::Sampler* sampler, int interval)
-      : base::Thread(base::Thread::Options("SamplingThread",
-                                           kSamplingThreadStackSize)),
-        sampler_(sampler),
-        interval_(interval) {}
-  void Run() override {
-    while (sampler_->IsProfiling()) {
-      sampler_->DoSample();
-      base::OS::Sleep(base::TimeDelta::FromMilliseconds(interval_));
-    }
-  }
-
- private:
-  sampler::Sampler* sampler_;
-  const int interval_;
-};
-
-
 // The Profiler samples pc and sp values for the main thread.
 // Each sample is appended to a circular buffer.
 // An independent thread removes data and writes it to the log.
 // This design minimizes the time spent in the sampler.
 //
 class Profiler: public base::Thread {
  public:
   explicit Profiler(Isolate* isolate);
   void Engage();
   void Disengage();
@@ skipping 52 matching lines @@
 
   // Tells whether we are currently recording tick samples.
   bool paused_;
 };
 
 
 //
 // Ticker used to provide ticks to the profiler and the sliding state
 // window.
 //
-class Ticker: public sampler::Sampler {
+class Ticker: public Sampler {
  public:
   Ticker(Isolate* isolate, int interval):
-      sampler::Sampler(reinterpret_cast<v8::Isolate*>(isolate)),
-      profiler_(NULL),
-      sampling_thread_(new SamplingThread(this, interval)) {}
+      Sampler(isolate, interval),
+      profiler_(NULL) {}
 
-  ~Ticker() {
-    if (IsActive()) Stop();
-    delete sampling_thread_;
+  ~Ticker() { if (IsActive()) Stop(); }
+
+  virtual void Tick(TickSample* sample) {
+    if (profiler_) profiler_->Insert(sample);
   }
 
   void SetProfiler(Profiler* profiler) {
     DCHECK(profiler_ == NULL);
     profiler_ = profiler;
     IncreaseProfilingDepth();
     if (!IsActive()) Start();
-    sampling_thread_->StartSynchronously();
   }
 
   void ClearProfiler() {
     profiler_ = NULL;
     if (IsActive()) Stop();
     DecreaseProfilingDepth();
-    sampling_thread_->Join();
-  }
-
-  void SampleStack(const v8::RegisterState& state) override {
-    v8::Isolate* v8_isolate = isolate();
-    Isolate* isolate = reinterpret_cast<Isolate*>(v8_isolate);
-#if defined(USE_SIMULATOR)
-    SimulatorHelper::FillRegisters(isolate,
-                                   const_cast<v8::RegisterState*>(&state));
-#endif
-    TickSample* sample = isolate->cpu_profiler()->StartTickSample();
-    TickSample sample_obj;
-    if (sample == NULL) sample = &sample_obj;
-    sample->Init(isolate, state, TickSample::kIncludeCEntryFrame, true);
-    if (is_counting_samples_ && !sample->timestamp.IsNull()) {
-      if (sample->state == JS) ++js_sample_count_;
-      if (sample->state == EXTERNAL) ++external_sample_count_;
-    }
-    if (profiler_) profiler_->Insert(sample);
-    if (sample != &sample_obj) {
-      isolate->cpu_profiler()->FinishTickSample();
-    }
   }
 
  private:
   Profiler* profiler_;
-  SamplingThread* sampling_thread_;
 };
 
 
 //
 // Profiler implementation.
 //
 Profiler::Profiler(Isolate* isolate)
     : base::Thread(Options("v8:Profiler")),
       isolate_(isolate),
       head_(0),
@@ skipping 1152 matching lines @@
     addCodeEventListener(jit_logger_);
     if (options & kJitCodeEventEnumExisting) {
       HandleScope scope(isolate_);
       LogCodeObjects();
       LogCompiledFunctions();
     }
   }
 }
 
 
-sampler::Sampler* Logger::sampler() {
+Sampler* Logger::sampler() {
   return ticker_;
 }
 
 
 FILE* Logger::TearDown() {
   if (!is_initialized_) return NULL;
   is_initialized_ = false;
 
   // Stop the profiler before closing the file.
   if (profiler_ != NULL) {
@@ skipping 27 matching lines @@
     removeCodeEventListener(jit_logger_);
     delete jit_logger_;
     jit_logger_ = NULL;
   }
 
   return log_->Close();
 }
 
 }  // namespace internal
 }  // namespace v8