Patch for allowing several V8 instances in process:...

src/log.cc

 // Copyright 2009 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 23 matching lines @@
 #include "log.h"
 #include "macro-assembler.h"
 #include "serialize.h"
 #include "string-stream.h"
 
 namespace v8 {
 namespace internal {
 
 #ifdef ENABLE_LOGGING_AND_PROFILING
 
+class LoggerPrivateData {
+ public:
+  // Tells whether we are currently recording tick samples.
+  bool profiler_paused_;
+
+  Address prev_to_;
+  Address prev_sp_;
+
+  LoggerPrivateData()
+    :profiler_paused_(false),
+    prev_to_(NULL),
+    prev_sp_(NULL) {
+  }
+};
+
 //
 // Sliding state window.  Updates counters to keep track of the last
 // window of kBufferSize states.  This is useful to track where we
 // spent our time.
 //
 class SlidingStateWindow {
  public:
   SlidingStateWindow();
   ~SlidingStateWindow();
   void AddState(StateTag state);
 
  private:
   static const int kBufferSize = 256;
   int current_index_;
   bool is_full_;
   byte buffer_[kBufferSize];
 
 
   void IncrementStateCounter(StateTag state) {
-    Counters::state_counters[state].Increment();
+    INC_COUNTER(state_counters[state]);
   }
 
 
   void DecrementStateCounter(StateTag state) {
-    Counters::state_counters[state].Decrement();
+    DEC_COUNTER(state_counters[state]);
   }
 };
 
 
 //
 // 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 Thread {
  public:
   Profiler();
   void Engage();
   void Disengage();
 
   // Inserts collected profiling data into buffer.
   void Insert(TickSample* sample) {
-    if (paused_)
+    if (v8_context()->logger_data_.private_data_.profiler_paused_)
       return;
 
     if (Succ(head_) == tail_) {
       overflow_ = true;
     } else {
       buffer_[head_] = *sample;
       head_ = Succ(head_);
       buffer_semaphore_->Signal();  // Tell we have an element.
     }
   }
 
   // Waits for a signal and removes profiling data.
   bool Remove(TickSample* sample) {
     buffer_semaphore_->Wait();  // Wait for an element.
     *sample = buffer_[tail_];
     bool result = overflow_;
     tail_ = Succ(tail_);
     overflow_ = false;
     return result;
   }
 
   void Run();
 
   // Pause and Resume TickSample data collection.
-  static bool paused() { return paused_; }
-  static void pause() { paused_ = true; }
-  static void resume() { paused_ = false; }
+  static bool paused() {
+    return v8_context()->logger_data_.private_data_.profiler_paused_;
+  }
+  static void pause() {
+    v8_context()->logger_data_.private_data_.profiler_paused_ = true;
+  }
+  static void resume() {
+    v8_context()->logger_data_.private_data_.profiler_paused_ = false;
+  }
 
  private:
   // Returns the next index in the cyclic buffer.
   int Succ(int index) { return (index + 1) % kBufferSize; }
 
   // Cyclic buffer for communicating profiling samples
   // between the signal handler and the worker thread.
   static const int kBufferSize = 128;
   TickSample buffer_[kBufferSize];  // Buffer storage.
   int head_;  // Index to the buffer head.
   int tail_;  // Index to the buffer tail.
   bool overflow_;  // Tell whether a buffer overflow has occurred.
   Semaphore* buffer_semaphore_;  // Sempahore used for buffer synchronization.
 
   // Tells whether profiler is engaged, that is, processing thread is stated.
   bool engaged_;
 
   // Tells whether worker thread should continue running.
   bool running_;
-
-  // Tells whether we are currently recording tick samples.
-  static bool paused_;
 };
 
-bool Profiler::paused_ = false;
 
 
 //
 // StackTracer implementation
 //
 void StackTracer::Trace(TickSample* sample) {
   if (sample->state == GC) {
     sample->frames_count = 0;
     return;
   }
 
   const Address js_entry_sp = Top::js_entry_sp(Top::GetCurrentThread());
   if (js_entry_sp == 0) {
     // Not executing JS now.
     sample->frames_count = 0;
     return;
   }
 
   int i = 0;
-  const Address callback = Logger::current_state_ != NULL ?
-      Logger::current_state_->external_callback() : NULL;
+  LoggerData& logger_data = v8_context()->logger_data_;
+  const Address callback = logger_data.current_state_ != NULL ?
+      logger_data.current_state_->external_callback() : NULL;
   if (callback != NULL) {
     sample->stack[i++] = callback;
   }
 
   SafeStackTraceFrameIterator it(
       reinterpret_cast<Address>(sample->fp),
       reinterpret_cast<Address>(sample->sp),
       reinterpret_cast<Address>(sample->sp),
       js_entry_sp);
   while (!it.done() && i < TickSample::kMaxFramesCount) {
@@ skipping 50 matching lines @@
 };
 
 
 //
 // SlidingStateWindow implementation.
 //
 SlidingStateWindow::SlidingStateWindow(): current_index_(0), is_full_(false) {
   for (int i = 0; i < kBufferSize; i++) {
     buffer_[i] = static_cast<byte>(OTHER);
   }
-  Logger::ticker_->SetWindow(this);
+  v8_context()->logger_data_.ticker_->SetWindow(this);
 }
 
 
 SlidingStateWindow::~SlidingStateWindow() {
-  Logger::ticker_->ClearWindow();
+  v8_context()->logger_data_.ticker_->ClearWindow();
 }
 
 
 void SlidingStateWindow::AddState(StateTag state) {
   if (is_full_) {
     DecrementStateCounter(static_cast<StateTag>(buffer_[current_index_]));
   } else if (current_index_ == kBufferSize - 1) {
     is_full_ = true;
   }
   buffer_[current_index_] = static_cast<byte>(state);
@@ skipping 24 matching lines @@
   // http://code.google.com/p/v8/issues/detail?id=487
   if (!FLAG_prof_lazy) {
     OS::LogSharedLibraryAddresses();
   }
 
   // Start thread processing the profiler buffer.
   running_ = true;
   Start();
 
   // Register to get ticks.
-  Logger::ticker_->SetProfiler(this);
+  v8_context()->logger_data_.ticker_->SetProfiler(this);
 
   Logger::ProfilerBeginEvent();
   Logger::LogAliases();
 }
 
 
 void Profiler::Disengage() {
   if (!engaged_) return;
 
   // Stop receiving ticks.
-  Logger::ticker_->ClearProfiler();
+  v8_context()->logger_data_.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.
   running_ = false;
   TickSample sample;
   // Reset 'paused_' flag, otherwise semaphore may not be signalled.
   resume();
   Insert(&sample);
   Join();
 
   LOG(UncheckedStringEvent("profiler", "end"));
 }
 
 
 void Profiler::Run() {
   TickSample sample;
-  bool overflow = Logger::profiler_->Remove(&sample);
+  LoggerData& logger_data = v8_context()->logger_data_;
+  bool overflow = logger_data.profiler_->Remove(&sample);
   while (running_) {
     LOG(TickEvent(&sample, overflow));
-    overflow = Logger::profiler_->Remove(&sample);
+    overflow = logger_data.profiler_->Remove(&sample);
   }
 }
 
 
 //
 // Logger class implementation.
 //
-Ticker* Logger::ticker_ = NULL;
-Profiler* Logger::profiler_ = NULL;
-VMState* Logger::current_state_ = NULL;
-VMState Logger::bottom_state_(EXTERNAL);
-SlidingStateWindow* Logger::sliding_state_window_ = NULL;
-const char** Logger::log_events_ = NULL;
-CompressionHelper* Logger::compression_helper_ = NULL;
-bool Logger::is_logging_ = false;
+LoggerData::LoggerData()
+  :private_data_(*new LoggerPrivateData()),
+  ticker_(NULL),
+  profiler_(NULL),
+  current_state_(NULL),
+  sliding_state_window_(NULL),
+  log_events_(NULL),
+  compression_helper_(NULL),
+  is_logging_(false),
+  bottom_state_(EXTERNAL) {
+}
+
+LoggerData::~LoggerData() {
+  delete &private_data_;
+}
 
 #define DECLARE_LONG_EVENT(ignore1, long_name, ignore2) long_name,
 const char* kLongLogEventsNames[Logger::NUMBER_OF_LOG_EVENTS] = {
   LOG_EVENTS_AND_TAGS_LIST(DECLARE_LONG_EVENT)
 };
 #undef DECLARE_LONG_EVENT
 
 #define DECLARE_SHORT_EVENT(ignore1, ignore2, short_name) short_name,
 const char* kCompressedLogEventsNames[Logger::NUMBER_OF_LOG_EVENTS] = {
   LOG_EVENTS_AND_TAGS_LIST(DECLARE_SHORT_EVENT)
@@ skipping 319 matching lines @@
   bool HandleMessage(LogMessageBuilder* msg) {
     if (!msg->StoreInCompressor(&compressor_)) {
       // Current message repeats the previous one, don't write it.
       ++repeat_count_;
       return false;
     }
     if (repeat_count_ == 0) {
       return msg->RetrieveCompressedPrevious(&compressor_);
     }
     OS::SNPrintF(prefix_, "%s,%d,",
-                 Logger::log_events_[Logger::REPEAT_META_EVENT],
-                 repeat_count_ + 1);
+      v8_context()->logger_data_.log_events_[Logger::REPEAT_META_EVENT],
+      repeat_count_ + 1);
     repeat_count_ = 0;
     return msg->RetrieveCompressedPrevious(&compressor_, prefix_.start());
   }
 
  private:
   LogRecordCompressor compressor_;
   int repeat_count_;
   EmbeddedVector<char, 20> prefix_;
 };
 
 #endif  // ENABLE_LOGGING_AND_PROFILING
 
 
 #ifdef ENABLE_LOGGING_AND_PROFILING
 void Logger::CallbackEventInternal(const char* prefix, const char* name,
                                    Address entry_point) {
   if (!Log::IsEnabled() || !FLAG_log_code) return;
   LogMessageBuilder msg;
-  msg.Append("%s,%s,",
-             log_events_[CODE_CREATION_EVENT], log_events_[CALLBACK_TAG]);
+  LoggerData& logger_data = v8_context()->logger_data_;
+  msg.Append("%s,%s,", logger_data.log_events_[CODE_CREATION_EVENT],
+    logger_data.log_events_[CALLBACK_TAG]);
   msg.AppendAddress(entry_point);
   msg.Append(",1,\"%s%s\"", prefix, name);
   if (FLAG_compress_log) {
-    ASSERT(compression_helper_ != NULL);
-    if (!compression_helper_->HandleMessage(&msg)) return;
+    ASSERT(logger_data.compression_helper_ != NULL);
+    if (!logger_data.compression_helper_->HandleMessage(&msg)) return;
   }
   msg.Append('\n');
   msg.WriteToLogFile();
 }
 #endif
 
 
 void Logger::CallbackEvent(String* name, Address entry_point) {
 #ifdef ENABLE_LOGGING_AND_PROFILING
   if (!Log::IsEnabled() || !FLAG_log_code) return;
@@ skipping 23 matching lines @@
 #endif
 }
 
 
 void Logger::CodeCreateEvent(LogEventsAndTags tag,
                              Code* code,
                              const char* comment) {
 #ifdef ENABLE_LOGGING_AND_PROFILING
   if (!Log::IsEnabled() || !FLAG_log_code) return;
   LogMessageBuilder msg;
-  msg.Append("%s,%s,", log_events_[CODE_CREATION_EVENT], log_events_[tag]);
+  LoggerData& logger_data = v8_context()->logger_data_;
+  msg.Append("%s,%s,", logger_data.log_events_[CODE_CREATION_EVENT],
+    logger_data.log_events_[tag]);
   msg.AppendAddress(code->address());
   msg.Append(",%d,\"", code->ExecutableSize());
   for (const char* p = comment; *p != '\0'; p++) {
     if (*p == '"') {
       msg.Append('\\');
     }
     msg.Append(*p);
   }
   msg.Append('"');
   if (FLAG_compress_log) {
-    ASSERT(compression_helper_ != NULL);
-    if (!compression_helper_->HandleMessage(&msg)) return;
+    ASSERT(logger_data.compression_helper_ != NULL);
+    if (!logger_data.compression_helper_->HandleMessage(&msg)) return;
   }
   msg.Append('\n');
   msg.WriteToLogFile();
 #endif
 }
 
 
 void Logger::CodeCreateEvent(LogEventsAndTags tag, Code* code, String* name) {
 #ifdef ENABLE_LOGGING_AND_PROFILING
   if (!Log::IsEnabled() || !FLAG_log_code) return;
   LogMessageBuilder msg;
   SmartPointer<char> str =
       name->ToCString(DISALLOW_NULLS, ROBUST_STRING_TRAVERSAL);
-  msg.Append("%s,%s,", log_events_[CODE_CREATION_EVENT], log_events_[tag]);
+  LoggerData& logger_data = v8_context()->logger_data_;
+  msg.Append("%s,%s,", logger_data.log_events_[CODE_CREATION_EVENT],
+    logger_data.log_events_[tag]);
   msg.AppendAddress(code->address());
   msg.Append(",%d,\"%s\"", code->ExecutableSize(), *str);
   if (FLAG_compress_log) {
-    ASSERT(compression_helper_ != NULL);
-    if (!compression_helper_->HandleMessage(&msg)) return;
+    ASSERT(logger_data.compression_helper_ != NULL);
+    if (!logger_data.compression_helper_->HandleMessage(&msg)) return;
   }
   msg.Append('\n');
   msg.WriteToLogFile();
 #endif
 }
 
 
 void Logger::CodeCreateEvent(LogEventsAndTags tag,
                              Code* code, String* name,
                              String* source, int line) {
 #ifdef ENABLE_LOGGING_AND_PROFILING
   if (!Log::IsEnabled() || !FLAG_log_code) return;
   LogMessageBuilder msg;
   SmartPointer<char> str =
       name->ToCString(DISALLOW_NULLS, ROBUST_STRING_TRAVERSAL);
   SmartPointer<char> sourcestr =
       source->ToCString(DISALLOW_NULLS, ROBUST_STRING_TRAVERSAL);
-  msg.Append("%s,%s,", log_events_[CODE_CREATION_EVENT], log_events_[tag]);
+  LoggerData& logger_data = v8_context()->logger_data_;
+  msg.Append("%s,%s,", logger_data.log_events_[CODE_CREATION_EVENT],
+    logger_data.log_events_[tag]);
   msg.AppendAddress(code->address());
   msg.Append(",%d,\"%s %s:%d\"",
              code->ExecutableSize(), *str, *sourcestr, line);
   if (FLAG_compress_log) {
-    ASSERT(compression_helper_ != NULL);
-    if (!compression_helper_->HandleMessage(&msg)) return;
+    ASSERT(logger_data.compression_helper_ != NULL);
+    if (!logger_data.compression_helper_->HandleMessage(&msg)) return;
   }
   msg.Append('\n');
   msg.WriteToLogFile();
 #endif
 }
 
 
 void Logger::CodeCreateEvent(LogEventsAndTags tag, Code* code, int args_count) {
 #ifdef ENABLE_LOGGING_AND_PROFILING
   if (!Log::IsEnabled() || !FLAG_log_code) return;
   LogMessageBuilder msg;
-  msg.Append("%s,%s,", log_events_[CODE_CREATION_EVENT], log_events_[tag]);
+  LoggerData& logger_data = v8_context()->logger_data_;
+  msg.Append("%s,%s,", logger_data.log_events_[CODE_CREATION_EVENT],
+    logger_data.log_events_[tag]);
   msg.AppendAddress(code->address());
   msg.Append(",%d,\"args_count: %d\"", code->ExecutableSize(), args_count);
   if (FLAG_compress_log) {
-    ASSERT(compression_helper_ != NULL);
-    if (!compression_helper_->HandleMessage(&msg)) return;
+    ASSERT(logger_data.compression_helper_ != NULL);
+    if (!logger_data.compression_helper_->HandleMessage(&msg)) return;
   }
   msg.Append('\n');
   msg.WriteToLogFile();
 #endif
 }
 
 
 void Logger::RegExpCodeCreateEvent(Code* code, String* source) {
 #ifdef ENABLE_LOGGING_AND_PROFILING
   if (!Log::IsEnabled() || !FLAG_log_code) return;
   LogMessageBuilder msg;
+  LoggerData& logger_data = v8_context()->logger_data_;
   msg.Append("%s,%s,",
-             log_events_[CODE_CREATION_EVENT], log_events_[REG_EXP_TAG]);
+    logger_data.log_events_[CODE_CREATION_EVENT],
+    logger_data.log_events_[REG_EXP_TAG]);
   msg.AppendAddress(code->address());
   msg.Append(",%d,\"", code->ExecutableSize());
   msg.AppendDetailed(source, false);
   msg.Append('\"');
   if (FLAG_compress_log) {
-    ASSERT(compression_helper_ != NULL);
-    if (!compression_helper_->HandleMessage(&msg)) return;
+    ASSERT(logger_data.compression_helper_ != NULL);
+    if (!logger_data.compression_helper_->HandleMessage(&msg)) return;
   }
   msg.Append('\n');
   msg.WriteToLogFile();
 #endif
 }
 
 
 void Logger::CodeMoveEvent(Address from, Address to) {
 #ifdef ENABLE_LOGGING_AND_PROFILING
-  static Address prev_to_ = NULL;
   if (!Log::IsEnabled() || !FLAG_log_code) return;
   LogMessageBuilder msg;
-  msg.Append("%s,", log_events_[CODE_MOVE_EVENT]);
+  LoggerData& logger_data = v8_context()->logger_data_;
+  msg.Append("%s,", logger_data.log_events_[CODE_MOVE_EVENT]);
   msg.AppendAddress(from);
   msg.Append(',');
-  msg.AppendAddress(to, prev_to_);
-  prev_to_ = to;
+  msg.AppendAddress(to, logger_data.private_data_.prev_to_);
+  logger_data.private_data_.prev_to_ = to;
   if (FLAG_compress_log) {
-    ASSERT(compression_helper_ != NULL);
-    if (!compression_helper_->HandleMessage(&msg)) return;
+    ASSERT(logger_data.compression_helper_ != NULL);
+    if (!logger_data.compression_helper_->HandleMessage(&msg)) return;
   }
   msg.Append('\n');
   msg.WriteToLogFile();
 #endif
 }
 
 
 void Logger::CodeDeleteEvent(Address from) {
 #ifdef ENABLE_LOGGING_AND_PROFILING
   if (!Log::IsEnabled() || !FLAG_log_code) return;
   LogMessageBuilder msg;
-  msg.Append("%s,", log_events_[CODE_DELETE_EVENT]);
+  LoggerData& logger_data = v8_context()->logger_data_;
+  msg.Append("%s,", logger_data.log_events_[CODE_DELETE_EVENT]);
   msg.AppendAddress(from);
   if (FLAG_compress_log) {
-    ASSERT(compression_helper_ != NULL);
-    if (!compression_helper_->HandleMessage(&msg)) return;
+    ASSERT(logger_data.compression_helper_ != NULL);
+    if (!logger_data.compression_helper_->HandleMessage(&msg)) return;
   }
   msg.Append('\n');
   msg.WriteToLogFile();
 #endif
 }
 
 
 void Logger::ResourceEvent(const char* name, const char* tag) {
 #ifdef ENABLE_LOGGING_AND_PROFILING
   if (!Log::IsEnabled() || !FLAG_log) return;
@@ skipping 167 matching lines @@
              parameter_string);
   DeleteArray(parameter_string);
   msg.WriteToLogFile();
 #endif
 }
 
 
 #ifdef ENABLE_LOGGING_AND_PROFILING
 void Logger::TickEvent(TickSample* sample, bool overflow) {
   if (!Log::IsEnabled() || !FLAG_prof) return;
-  static Address prev_sp = NULL;
+
   LogMessageBuilder msg;
-  msg.Append("%s,", log_events_[TICK_EVENT]);
+  LoggerData& logger_data = v8_context()->logger_data_;
+  msg.Append("%s,", logger_data.log_events_[TICK_EVENT]);
   Address prev_addr = reinterpret_cast<Address>(sample->pc);
   msg.AppendAddress(prev_addr);
   msg.Append(',');
-  msg.AppendAddress(reinterpret_cast<Address>(sample->sp), prev_sp);
-  prev_sp = reinterpret_cast<Address>(sample->sp);
+  msg.AppendAddress(reinterpret_cast<Address>(sample->sp),
+    logger_data.private_data_.prev_sp_);
+  logger_data.private_data_.prev_sp_ = reinterpret_cast<Address>(sample->sp);
   msg.Append(",%d", static_cast<int>(sample->state));
   if (overflow) {
     msg.Append(",overflow");
   }
   for (int i = 0; i < sample->frames_count; ++i) {
     msg.Append(',');
     msg.AppendAddress(sample->stack[i], prev_addr);
     prev_addr = sample->stack[i];
   }
   if (FLAG_compress_log) {
-    ASSERT(compression_helper_ != NULL);
-    if (!compression_helper_->HandleMessage(&msg)) return;
+    ASSERT(logger_data.compression_helper_ != NULL);
+    if (!logger_data.compression_helper_->HandleMessage(&msg)) return;
   }
   msg.Append('\n');
   msg.WriteToLogFile();
 }
 
 
 int Logger::GetActiveProfilerModules() {
   int result = PROFILER_MODULE_NONE;
-  if (!profiler_->paused()) {
+  if (!v8_context()->logger_data_.profiler_->paused()) {
     result |= PROFILER_MODULE_CPU;
   }
   if (FLAG_log_gc) {
     result |= PROFILER_MODULE_HEAP_STATS | PROFILER_MODULE_JS_CONSTRUCTORS;
   }
   return result;
 }
 
 
 void Logger::PauseProfiler(int flags) {
   if (!Log::IsEnabled()) return;
   const int active_modules = GetActiveProfilerModules();
   const int modules_to_disable = active_modules & flags;
   if (modules_to_disable == PROFILER_MODULE_NONE) return;
 
+  LoggerData& logger_data = v8_context()->logger_data_;
   if (modules_to_disable & PROFILER_MODULE_CPU) {
-    profiler_->pause();
+    logger_data.profiler_->pause();
     if (FLAG_prof_lazy) {
-      if (!FLAG_sliding_state_window) ticker_->Stop();
+      if (!FLAG_sliding_state_window) logger_data.ticker_->Stop();
       FLAG_log_code = false;
       // Must be the same message as Log::kDynamicBufferSeal.
       LOG(UncheckedStringEvent("profiler", "pause"));
     }
   }
   if (modules_to_disable &
       (PROFILER_MODULE_HEAP_STATS | PROFILER_MODULE_JS_CONSTRUCTORS)) {
     FLAG_log_gc = false;
   }
   // Turn off logging if no active modules remain.
   if ((active_modules & ~flags) == PROFILER_MODULE_NONE) {
-    is_logging_ = false;
+    logger_data.is_logging_ = false;
   }
 }
 
 
 void Logger::ResumeProfiler(int flags) {
   if (!Log::IsEnabled()) return;
   const int modules_to_enable = ~GetActiveProfilerModules() & flags;
+  LoggerData& logger_data = v8_context()->logger_data_;
   if (modules_to_enable != PROFILER_MODULE_NONE) {
-    is_logging_ = true;
+    logger_data.is_logging_ = true;
   }
   if (modules_to_enable & PROFILER_MODULE_CPU) {
     if (FLAG_prof_lazy) {
-      profiler_->Engage();
+      logger_data.profiler_->Engage();
       LOG(UncheckedStringEvent("profiler", "resume"));
       FLAG_log_code = true;
       LogCompiledFunctions();
       LogAccessorCallbacks();
-      if (!FLAG_sliding_state_window) ticker_->Start();
+      if (!FLAG_sliding_state_window) logger_data.ticker_->Start();
     }
-    profiler_->resume();
+    logger_data.profiler_->resume();
   }
   if (modules_to_enable &
       (PROFILER_MODULE_HEAP_STATS | PROFILER_MODULE_JS_CONSTRUCTORS)) {
     FLAG_log_gc = true;
   }
 }
 
 
 // This function can be called when Log's mutex is acquired,
 // either from main or Profiler's thread.
 void Logger::StopLoggingAndProfiling() {
   Log::stop();
   PauseProfiler(PROFILER_MODULE_CPU);
 }
 
 
 bool Logger::IsProfilerSamplerActive() {
-  return ticker_->IsActive();
+  return v8_context()->logger_data_.ticker_->IsActive();
 }
 
 
 int Logger::GetLogLines(int from_pos, char* dest_buf, int max_size) {
   return Log::GetLogLines(from_pos, dest_buf, max_size);
 }
 
 
 static int EnumerateCompiledFunctions(Handle<SharedFunctionInfo>* sfis) {
   AssertNoAllocation no_alloc;
@@ skipping 202 matching lines @@
         } else {
           stream.Put(*p);
         }
       }
       SmartPointer<const char> expanded = stream.ToCString();
       Log::OpenFile(*expanded);
     } else {
       Log::OpenFile(FLAG_logfile);
     }
   }
+  LoggerData& logger_data = v8_context()->logger_data_;
+  logger_data.current_state_ = &logger_data.bottom_state_;
 
-  current_state_ = &bottom_state_;
+  logger_data.ticker_ = new Ticker(kSamplingIntervalMs);
 
-  ticker_ = new Ticker(kSamplingIntervalMs);
-
-  if (FLAG_sliding_state_window && sliding_state_window_ == NULL) {
-    sliding_state_window_ = new SlidingStateWindow();
+  if (FLAG_sliding_state_window && logger_data.sliding_state_window_ == NULL) {
+    logger_data.sliding_state_window_ = new SlidingStateWindow();
   }
 
-  log_events_ = FLAG_compress_log ?
+  logger_data.log_events_ = FLAG_compress_log ?
       kCompressedLogEventsNames : kLongLogEventsNames;
   if (FLAG_compress_log) {
-    compression_helper_ = new CompressionHelper(kCompressionWindowSize);
+    logger_data.compression_helper_ =
+      new CompressionHelper(kCompressionWindowSize);
   }
 
-  is_logging_ = start_logging;
+  logger_data.is_logging_ = start_logging;
 
   if (FLAG_prof) {
-    profiler_ = new Profiler();
+    logger_data.profiler_ = new Profiler();
     if (!FLAG_prof_auto) {
-      profiler_->pause();
+      logger_data.profiler_->pause();
     } else {
-      is_logging_ = true;
+      logger_data.is_logging_ = true;
     }
     if (!FLAG_prof_lazy) {
-      profiler_->Engage();
+      logger_data.profiler_->Engage();
     }
   }
 
-  LogMessageBuilder::set_write_failure_handler(StopLoggingAndProfiling);
+  v8_context()->log_data_.set_write_failure_handler(StopLoggingAndProfiling);
 
   return true;
 
 #else
   return false;
 #endif
 }
 
 
 void Logger::TearDown() {
 #ifdef ENABLE_LOGGING_AND_PROFILING
-  LogMessageBuilder::set_write_failure_handler(NULL);
+  LoggerData& logger_data = v8_context()->logger_data_;
+  v8_context()->log_data_.set_write_failure_handler(NULL);
 
   // Stop the profiler before closing the file.
-  if (profiler_ != NULL) {
-    profiler_->Disengage();
-    delete profiler_;
-    profiler_ = NULL;
+  if (logger_data.profiler_ != NULL) {
+    logger_data.profiler_->Disengage();
+    delete logger_data.profiler_;
+    logger_data.profiler_ = NULL;
   }
 
-  delete compression_helper_;
-  compression_helper_ = NULL;
+  delete logger_data.compression_helper_;
+  logger_data.compression_helper_ = NULL;
 
-  delete sliding_state_window_;
-  sliding_state_window_ = NULL;
+  delete logger_data.sliding_state_window_;
+  logger_data.sliding_state_window_ = NULL;
 
-  delete ticker_;
-  ticker_ = NULL;
+  delete logger_data.ticker_;
+  logger_data.ticker_ = NULL;
 
   Log::Close();
 #endif
 }
 
 
 void Logger::EnableSlidingStateWindow() {
 #ifdef ENABLE_LOGGING_AND_PROFILING
+  LoggerData& logger_data = v8_context()->logger_data_;
   // If the ticker is NULL, Logger::Setup has not been called yet.  In
   // that case, we set the sliding_state_window flag so that the
   // sliding window computation will be started when Logger::Setup is
   // called.
-  if (ticker_ == NULL) {
+  if (logger_data.ticker_ == NULL) {
     FLAG_sliding_state_window = true;
     return;
   }
   // Otherwise, if the sliding state window computation has not been
   // started we do it now.
-  if (sliding_state_window_ == NULL) {
-    sliding_state_window_ = new SlidingStateWindow();
+  if (logger_data.sliding_state_window_ == NULL) {
+    logger_data.sliding_state_window_ = new SlidingStateWindow();
   }
 #endif
 }
 
 
 } }  // namespace v8::internal