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

src/log.h

 // Copyright 2006-2008 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 121 matching lines @@
   V(FUNCTION_TAG,                   "Function",               "f")        \
   V(KEYED_LOAD_IC_TAG,              "KeyedLoadIC",            "klic")     \
   V(KEYED_STORE_IC_TAG,             "KeyedStoreIC",           "ksic")     \
   V(LAZY_COMPILE_TAG,               "LazyCompile",            "lc")       \
   V(LOAD_IC_TAG,                    "LoadIC",                 "lic")      \
   V(REG_EXP_TAG,                    "RegExp",                 "re")       \
   V(SCRIPT_TAG,                     "Script",                 "sc")       \
   V(STORE_IC_TAG,                   "StoreIC",                "sic")      \
   V(STUB_TAG,                       "Stub",                   "s")
 
+class LoggerPrivateData;
+
+class LoggerData {
+  #ifdef ENABLE_LOGGING_AND_PROFILING
+  // The sampler used by the profiler and the sliding state window.
+    Ticker* ticker_;
+
+    // When the statistical profile is active, profiler_
+    // points to a Profiler, that handles collection
+    // of samples.
+    Profiler* profiler_;
+
+    // A stack of VM states.
+    VMState* current_state_;
+
+    // Singleton bottom or default vm state.
+    VMState bottom_state_;
+
+    // SlidingStateWindow instance keeping a sliding window of the most
+    // recent VM states.
+    SlidingStateWindow* sliding_state_window_;
+
+    // An array of log events names.
+    const char** log_events_;
+
+    // An instance of helper created if log compression is enabled.
+    CompressionHelper* compression_helper_;
+
+    bool is_logging_;
+
+    LoggerPrivateData& private_data_;
+  #endif
+
+  friend class V8Context;
+  friend class Logger;
+  friend class VMState;
+  friend class Profiler;
+  friend class SlidingStateWindow;
+  friend class StackTracer;
+  friend class CompressionHelper;
+
+  LoggerData();
+  ~LoggerData();
+  DISALLOW_COPY_AND_ASSIGN(LoggerData);
+};
+
 class Logger {
  public:
 #define DECLARE_ENUM(enum_item, ignore1, ignore2) enum_item,
   enum LogEventsAndTags {
     LOG_EVENTS_AND_TAGS_LIST(DECLARE_ENUM)
     NUMBER_OF_LOG_EVENTS
   };
 #undef DECLARE_ENUM
 
   // Acquires resources for logging if the right flags are set.
@@ skipping 96 matching lines @@
   // ==== Events logged by --log-regexp ====
   // Regexp compilation and execution events.
 
   static void RegExpCompileEvent(Handle<JSRegExp> regexp, bool in_cache);
 
   // Log an event reported from generated code
   static void LogRuntime(Vector<const char> format, JSArray* args);
 
 #ifdef ENABLE_LOGGING_AND_PROFILING
   static StateTag state() {
-    return current_state_ ? current_state_->state() : OTHER;
+    LoggerData& data = v8_context()->logger_data_;
+    return data.current_state_ ? data.current_state_->state() : OTHER;
   }
 
   static bool is_logging() {
-    return is_logging_;
+    V8Context* const v8context = v8_context();
+    return v8context != NULL ? v8context->logger_data_.is_logging_:false;
   }
 
   // Pause/Resume collection of profiling data.
   // When data collection is paused, CPU Tick events are discarded until
   // data collection is Resumed.
   static void PauseProfiler(int flags);
   static void ResumeProfiler(int flags);
   static int GetActiveProfilerModules();
 
   // If logging is performed into a memory buffer, allows to
@@ skipping 36 matching lines @@
 
   // Logs a StringEvent regardless of whether FLAG_log is true.
   static void UncheckedStringEvent(const char* name, const char* value);
 
   // Stops logging and profiling in case of insufficient resources.
   static void StopLoggingAndProfiling();
 
   // Returns whether profiler's sampler is active.
   static bool IsProfilerSamplerActive();
 
-  // The sampler used by the profiler and the sliding state window.
-  static Ticker* ticker_;
-
-  // When the statistical profile is active, profiler_
-  // points to a Profiler, that handles collection
-  // of samples.
-  static Profiler* profiler_;
-
-  // A stack of VM states.
-  static VMState* current_state_;
-
-  // Singleton bottom or default vm state.
-  static VMState bottom_state_;
-
-  // SlidingStateWindow instance keeping a sliding window of the most
-  // recent VM states.
-  static SlidingStateWindow* sliding_state_window_;
-
-  // An array of log events names.
-  static const char** log_events_;
-
-  // An instance of helper created if log compression is enabled.
-  static CompressionHelper* compression_helper_;
-
   // Internal implementation classes with access to
   // private members.
   friend class CompressionHelper;
   friend class EventLog;
   friend class TimeLog;
   friend class Profiler;
-  friend class SlidingStateWindow;
   friend class StackTracer;
   friend class VMState;
 
   friend class LoggerTestHelper;
-
-  static bool is_logging_;
 #else
   static bool is_logging() { return false; }
 #endif
 };
 
 
 // Class that extracts stack trace, used for profiling.
 class StackTracer : public AllStatic {
  public:
   static void Trace(TickSample* sample);
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_LOG_H_