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

src/counters.h

 // Copyright 2007-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 13 matching lines @@
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifndef V8_COUNTERS_H_
 #define V8_COUNTERS_H_
 
 namespace v8 {
 namespace internal {
 
+class StatsTableData {
+  CounterLookupCallback lookup_function_;
+  CreateHistogramCallback create_histogram_function_;
+  AddHistogramSampleCallback add_histogram_sample_function_;
+  StatsTableData();
+
+  friend class StatsTable;
+  friend class V8Context;
+  DISALLOW_COPY_AND_ASSIGN(StatsTableData);
+};
+
 // StatsCounters is an interface for plugging into external
 // counters for monitoring.  Counters can be looked up and
 // manipulated by name.
 
 class StatsTable : public AllStatic {
  public:
   // Register an application-defined function where
   // counters can be looked up.
   static void SetCounterFunction(CounterLookupCallback f) {
-    lookup_function_ = f;
+    v8_context()->stats_table_data_.lookup_function_ = f;
   }
 
   // Register an application-defined function to create
   // a histogram for passing to the AddHistogramSample function
   static void SetCreateHistogramFunction(CreateHistogramCallback f) {
-    create_histogram_function_ = f;
+    v8_context()->stats_table_data_.create_histogram_function_ = f;
   }
 
   // Register an application-defined function to add a sample
   // to a histogram created with CreateHistogram function
   static void SetAddHistogramSampleFunction(AddHistogramSampleCallback f) {
-    add_histogram_sample_function_ = f;
+    v8_context()->stats_table_data_.add_histogram_sample_function_ = f;
   }
 
   static bool HasCounterFunction() {
-    return lookup_function_ != NULL;
+    return v8_context()->stats_table_data_.lookup_function_ != NULL;
   }
 
   // Lookup the location of a counter by name.  If the lookup
   // is successful, returns a non-NULL pointer for writing the
   // value of the counter.  Each thread calling this function
   // may receive a different location to store it's counter.
   // The return value must not be cached and re-used across
   // threads, although a single thread is free to cache it.
   static int *FindLocation(const char* name) {
-    if (!lookup_function_) return NULL;
-    return lookup_function_(name);
+    CounterLookupCallback lookup_function =
+      v8_context()->stats_table_data_.lookup_function_;
+    if (!lookup_function) return NULL;
+    return lookup_function(name);
   }
 
   // Create a histogram by name. If the create is successful,
   // returns a non-NULL pointer for use with AddHistogramSample
   // function. min and max define the expected minimum and maximum
   // sample values. buckets is the maximum number of buckets
   // that the samples will be grouped into.
   static void* CreateHistogram(const char* name,
                                int min,
                                int max,
                                size_t buckets) {
-    if (!create_histogram_function_) return NULL;
-    return create_histogram_function_(name, min, max, buckets);
+    CreateHistogramCallback create_histogram_function =
+      v8_context()->stats_table_data_.create_histogram_function_;
+    if (!create_histogram_function) return NULL;
+    return create_histogram_function(name, min, max, buckets);
   }
 
   // Add a sample to a histogram created with the CreateHistogram
   // function.
   static void AddHistogramSample(void* histogram, int sample) {
-    if (!add_histogram_sample_function_) return;
-    return add_histogram_sample_function_(histogram, sample);
+    AddHistogramSampleCallback add_histogram_sample_function =
+      v8_context()->stats_table_data_.add_histogram_sample_function_;
+    if (!add_histogram_sample_function) return;
+    return add_histogram_sample_function(histogram, sample);
   }
-
- private:
-  static CounterLookupCallback lookup_function_;
-  static CreateHistogramCallback create_histogram_function_;
-  static AddHistogramSampleCallback add_histogram_sample_function_;
 };
 
 // StatsCounters are dynamically created values which can be tracked in
 // the StatsTable.  They are designed to be lightweight to create and
 // easy to use.
 //
 // Internally, a counter represents a value in a row of a StatsTable.
 // The row has a 32bit value for each process/thread in the table and also
 // a name (stored in the table metadata).  Since the storage location can be
 // thread-specific, this class cannot be shared across threads.
@@ skipping 123 matching lines @@
     timer_->Stop();
   }
  private:
   HistogramTimer* timer_;
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_COUNTERS_H_