Make use of v8::TickSample instead of v8::internal::TickSample in logger.

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/counters.h"
 #include "src/deoptimizer.h"
 #include "src/global-handles.h"
 #include "src/interpreter/bytecodes.h"
 #include "src/interpreter/interpreter.h"
 #include "src/libsampler/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/profiler-listener.h"
 #include "src/profiler/tick-sample.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* kLogEventsNames[CodeEventListener::NUMBER_OF_LOG_EVENTS] = {
     LOG_EVENTS_AND_TAGS_LIST(DECLARE_EVENT)};
 #undef DECLARE_EVENT
 
 static const char* ComputeMarker(SharedFunctionInfo* shared,
                                  AbstractCode* code) {
   switch (code->kind()) {
     case AbstractCode::FUNCTION:
     case AbstractCode::INTERPRETED_FUNCTION:
@@ skipping 505 matching lines @@
 // 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();
 
   // Inserts collected profiling data into buffer.
-  void Insert(TickSample* sample) {
+  void Insert(v8::TickSample* sample) {
     if (paused_)
       return;
 
     if (Succ(head_) == static_cast<int>(base::NoBarrier_Load(&tail_))) {
       overflow_ = true;
     } else {
       buffer_[head_] = *sample;
       head_ = Succ(head_);
       buffer_semaphore_.Signal();  // Tell we have an element.
     }
   }
 
   virtual void Run();
 
   // Pause and Resume TickSample data collection.
   void pause() { paused_ = true; }
   void resume() { paused_ = false; }
 
  private:
   // Waits for a signal and removes profiling data.
-  bool Remove(TickSample* sample) {
+  bool Remove(v8::TickSample* sample) {
     buffer_semaphore_.Wait();  // Wait for an element.
     *sample = buffer_[base::NoBarrier_Load(&tail_)];
     bool result = overflow_;
     base::NoBarrier_Store(&tail_, static_cast<base::Atomic32>(
                                       Succ(base::NoBarrier_Load(&tail_))));
     overflow_ = false;
     return result;
   }
 
   // Returns the next index in the cyclic buffer.
   int Succ(int index) { return (index + 1) % kBufferSize; }
 
   Isolate* isolate_;
   // Cyclic buffer for communicating profiling samples
   // between the signal handler and the worker thread.
   static const int kBufferSize = 128;
-  TickSample buffer_[kBufferSize];  // Buffer storage.
+  v8::TickSample buffer_[kBufferSize];  // Buffer storage.
   int head_;  // Index to the buffer head.
   base::Atomic32 tail_;             // Index to the buffer tail.
   bool overflow_;  // Tell whether a buffer overflow has occurred.
   // Sempahore used for buffer synchronization.
   base::Semaphore buffer_semaphore_;
 
   // Tells whether profiler is engaged, that is, processing thread is stated.
   bool engaged_;
 
   // Tells whether worker thread should continue running.
   base::Atomic32 running_;
 
   // 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 {
  public:
-  Ticker(Isolate* isolate, int interval):
-      sampler::Sampler(reinterpret_cast<v8::Isolate*>(isolate)),
-      profiler_(NULL),
-      sampling_thread_(new SamplingThread(this, interval)) {}
+  Ticker(Isolate* isolate, int interval)
+      : sampler::Sampler(reinterpret_cast<v8::Isolate*>(isolate)),
+        profiler_(nullptr),
+        sampling_thread_(new SamplingThread(this, interval)) {}
 
   ~Ticker() {
     if (IsActive()) Stop();
     delete sampling_thread_;
   }
 
   void SetProfiler(Profiler* profiler) {
-    DCHECK(profiler_ == NULL);
+    DCHECK(profiler_ == nullptr);
     profiler_ = profiler;
     IncreaseProfilingDepth();
     if (!IsActive()) Start();
     sampling_thread_->StartSynchronously();
   }
 
   void ClearProfiler() {
-    profiler_ = NULL;
+    profiler_ = nullptr;
     if (IsActive()) Stop();
     DecreaseProfilingDepth();
     sampling_thread_->Join();
   }
 
   void SampleStack(const v8::RegisterState& state) override {
     if (!profiler_) return;
-    v8::Isolate* v8_isolate = isolate();
-    Isolate* i_isolate = reinterpret_cast<Isolate*>(v8_isolate);
 #if defined(USE_SIMULATOR)
-    if (!SimulatorHelper::FillRegisters(i_isolate,
-                                        const_cast<v8::RegisterState*>(&state)))
-      return;
+    Isolate* i_isolate = reinterpret_cast<Isolate*>(isolate());
+    v8::RegisterState regs;
+    if (!SimulatorHelper::FillRegisters(i_isolate, &regs)) return;
+#else
+    const v8::RegisterState& regs = state;
 #endif
-    TickSample sample;
-    sample.Init(i_isolate, state, TickSample::kIncludeCEntryFrame, true);
+    v8::TickSample sample;
+    sample.Init(isolate(), regs, v8::TickSample::kIncludeCEntryFrame, true);
     profiler_->Insert(&sample);
   }
 
  private:
   Profiler* profiler_;
   SamplingThread* sampling_thread_;
 };
 
 
 //
@@ skipping 39 matching lines @@
 void Profiler::Disengage() {
   if (!engaged_) return;
 
   // Stop receiving ticks.
   isolate_->logger()->ticker_->ClearProfiler();
 
   // Terminate the worker thread by setting running_ to false,
   // inserting a fake element in the queue and then wait for
   // the thread to terminate.
   base::NoBarrier_Store(&running_, 0);
-  TickSample sample;
+  v8::TickSample sample;
   // Reset 'paused_' flag, otherwise semaphore may not be signalled.
   resume();
   Insert(&sample);
   Join();
 
   LOG(isolate_, UncheckedStringEvent("profiler", "end"));
 }
 
 
 void Profiler::Run() {
-  TickSample sample;
+  v8::TickSample sample;
   bool overflow = Remove(&sample);
   while (base::NoBarrier_Load(&running_)) {
     LOG(isolate_, TickEvent(&sample, overflow));
     overflow = Remove(&sample);
   }
 }
 
 
 //
 // Logger class implementation.
@@ skipping 621 matching lines @@
   RuntimeCallTimer* timer = stats->current_timer();
   if (timer == nullptr) return;
   RuntimeCallCounter* counter = timer->counter();
   if (counter == nullptr) return;
   Log::MessageBuilder msg(log_);
   msg.Append("active-runtime-timer,");
   msg.AppendDoubleQuotedString(counter->name);
   msg.WriteToLogFile();
 }
 
-void Logger::TickEvent(TickSample* sample, bool overflow) {
+void Logger::TickEvent(v8::TickSample* sample, bool overflow) {
   if (!log_->IsEnabled() || !FLAG_prof_cpp) return;
   if (FLAG_runtime_call_stats) {
     RuntimeCallTimerEvent();
   }
   Log::MessageBuilder msg(log_);
   msg.Append("%s,", kLogEventsNames[CodeEventListener::TICK_EVENT]);
   msg.AppendAddress(reinterpret_cast<Address>(sample->pc));
   msg.Append(",%d", static_cast<int>(timer_.Elapsed().InMicroseconds()));
   if (sample->has_external_callback) {
     msg.Append(",1,");
@@ skipping 490 matching lines @@
 
   if (profiler_listener_.get() != nullptr) {
     removeCodeEventListener(profiler_listener_.get());
   }
 
   return log_->Close();
 }
 
 }  // namespace internal
 }  // namespace v8