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

src/global-handles.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 14 matching lines @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "v8.h"
 
 #include "api.h"
 #include "global-handles.h"
 
 namespace v8 {
 namespace internal {
-
-class GlobalHandles::Node : public Malloced {
+class GlobalHandlesData::Node : public Malloced {
  public:
 
   void Initialize(Object* object) {
     // Set the initial value of the handle.
     object_ = object;
     state_  = NORMAL;
     parameter_or_next_free_.parameter = NULL;
     callback_ = NULL;
   }
 
@@ skipping 12 matching lines @@
 #ifdef DEBUG
     // Zap the values for eager trapping.
     object_ = NULL;
     next_ = NULL;
     parameter_or_next_free_.next_free = NULL;
 #endif
   }
 
   void Destroy() {
     if (state_ == WEAK || IsNearDeath()) {
-      GlobalHandles::number_of_weak_handles_--;
+      v8_context()->global_handles_data_.number_of_weak_handles_--;
       if (object_->IsJSGlobalObject()) {
-        GlobalHandles::number_of_global_object_weak_handles_--;
+        v8_context()->global_handles_data_.
+          number_of_global_object_weak_handles_--;
       }
     }
     state_ = DESTROYED;
   }
 
   // Accessors for next_.
   Node* next() { return next_; }
   void set_next(Node* value) { next_ = value; }
   Node** next_addr() { return &next_; }
 
@@ skipping 14 matching lines @@
   }
 
   // Returns the handle.
   Handle<Object> handle() { return Handle<Object>(&object_); }
 
   // Make this handle weak.
   void MakeWeak(void* parameter, WeakReferenceCallback callback) {
     LOG(HandleEvent("GlobalHandle::MakeWeak", handle().location()));
     ASSERT(state_ != DESTROYED);
     if (state_ != WEAK && !IsNearDeath()) {
-      GlobalHandles::number_of_weak_handles_++;
+      v8_context()->global_handles_data_.number_of_weak_handles_++;
       if (object_->IsJSGlobalObject()) {
-        GlobalHandles::number_of_global_object_weak_handles_++;
+        v8_context()->global_handles_data_.
+          number_of_global_object_weak_handles_++;
       }
     }
     state_ = WEAK;
     set_parameter(parameter);
     callback_ = callback;
   }
 
   void ClearWeakness() {
     LOG(HandleEvent("GlobalHandle::ClearWeakness", handle().location()));
     ASSERT(state_ != DESTROYED);
     if (state_ == WEAK || IsNearDeath()) {
-      GlobalHandles::number_of_weak_handles_--;
+      v8_context()->global_handles_data_.number_of_weak_handles_--;
       if (object_->IsJSGlobalObject()) {
-        GlobalHandles::number_of_global_object_weak_handles_--;
+        v8_context()->global_handles_data_.
+          number_of_global_object_weak_handles_--;
       }
     }
     state_ = NORMAL;
     set_parameter(NULL);
   }
 
   bool IsNearDeath() {
     // Check for PENDING to ensure correct answer when processing callbacks.
     return state_ == PENDING || state_ == NEAR_DEATH;
   }
@@ skipping 24 matching lines @@
     // The callback function is resolved as late as possible to preserve old
     // behavior.
     WeakReferenceCallback func = callback();
     if (func == NULL) return false;
 
     v8::Persistent<v8::Object> object = ToApi<v8::Object>(handle());
     {
       // Forbid reuse of destroyed nodes as they might be already deallocated.
       // It's fine though to reuse nodes that were destroyed in weak callback
       // as those cannot be deallocated until we are back from the callback.
-      set_first_free(NULL);
-      if (first_deallocated()) {
-        first_deallocated()->set_next(head());
+      GlobalHandles::set_first_free(NULL);
+      if (GlobalHandles::first_deallocated()) {
+        GlobalHandles::first_deallocated()->set_next(GlobalHandles::head());
       }
       // Leaving V8.
       VMState state(EXTERNAL);
       func(object, par);
     }
     return true;
   }
 
   // Place the handle address first to avoid offset computation.
   Object* object_;  // Storage for object pointer.
@@ skipping 71 matching lines @@
       next_ = new_nodes + 1;
       limit_ = new_nodes + kNodesPerChunk;
       return new_nodes;
     }
 
     Chunk* current_;
     Node* next_;
     Node* limit_;
 };
 
-
-static GlobalHandles::Pool pool_;
-
+class GlobalHandlesPrivateData {
+ public:
+  GlobalHandles::Pool pool_;
+};
 
 Handle<Object> GlobalHandles::Create(Object* value) {
-  Counters::global_handles.Increment();
+  INC_COUNTER(global_handles);
   Node* result;
   if (first_free()) {
     // Take the first node in the free list.
     result = first_free();
     set_first_free(result->next_free());
   } else if (first_deallocated()) {
     // Next try deallocated list
     result = first_deallocated();
     set_first_deallocated(result->next_free());
     ASSERT(result->next() == head());
     set_head(result);
   } else {
     // Allocate a new node.
-    result = pool_.Allocate();
+    result = v8_context()->global_handles_data_.private_data_.pool_.Allocate();
     result->set_next(head());
     set_head(result);
   }
   result->Initialize(value);
   return result->handle();
 }
 
 
 void GlobalHandles::Destroy(Object** location) {
-  Counters::global_handles.Decrement();
+  DEC_COUNTER(global_handles);
   if (location == NULL) return;
   Node* node = Node::FromLocation(location);
   node->Destroy();
   // Link the destroyed.
   node->set_next_free(first_free());
   set_first_free(node);
 }
 
 
 void GlobalHandles::MakeWeak(Object** location, void* parameter,
@@ skipping 14 matching lines @@
 
 
 bool GlobalHandles::IsWeak(Object** location) {
   return Node::FromLocation(location)->IsWeak();
 }
 
 
 void GlobalHandles::IterateWeakRoots(ObjectVisitor* v) {
   // Traversal of GC roots in the global handle list that are marked as
   // WEAK or PENDING.
-  for (Node* current = head_; current != NULL; current = current->next()) {
+  for (Node* current = v8_context()->global_handles_data_.head_;
+       current != NULL;
+       current = current->next()) {
     if (current->state_ == Node::WEAK
       || current->state_ == Node::PENDING
       || current->state_ == Node::NEAR_DEATH) {
       v->VisitPointer(&current->object_);
     }
   }
 }
 
 
 void GlobalHandles::IterateWeakRoots(WeakReferenceGuest f,
                                      WeakReferenceCallback callback) {
-  for (Node* current = head_; current != NULL; current = current->next()) {
+  for (Node* current = v8_context()->global_handles_data_.head_;
+       current != NULL;
+       current = current->next()) {
     if (current->IsWeak() && current->callback() == callback) {
       f(current->object_, current->parameter());
     }
   }
 }
 
 
 void GlobalHandles::IdentifyWeakHandles(WeakSlotCallback f) {
-  for (Node* current = head_; current != NULL; current = current->next()) {
+  for (Node* current = v8_context()->global_handles_data_.head_;
+       current != NULL;
+       current = current->next()) {
     if (current->state_ == Node::WEAK) {
       if (f(&current->object_)) {
         current->state_ = Node::PENDING;
         LOG(HandleEvent("GlobalHandle::Pending", current->handle().location()));
       }
     }
   }
 }
 
 
 int post_gc_processing_count = 0;
 
 void GlobalHandles::PostGarbageCollectionProcessing() {
   // Process weak global handle callbacks. This must be done after the
   // GC is completely done, because the callbacks may invoke arbitrary
   // API functions.
   // At the same time deallocate all DESTROYED nodes.
   ASSERT(Heap::gc_state() == Heap::NOT_IN_GC);
   const int initial_post_gc_processing_count = ++post_gc_processing_count;
-  Node** p = &head_;
+  Node** p = &v8_context()->global_handles_data_.head_;
   while (*p != NULL) {
     if ((*p)->PostGarbageCollectionProcessing()) {
       if (initial_post_gc_processing_count != post_gc_processing_count) {
         // Weak callback triggered another GC and another round of
         // PostGarbageCollection processing.  The current node might
         // have been deleted in that round, so we need to bail out (or
         // restart the processing).
         break;
       }
     }
@@ skipping 12 matching lines @@
   }
   set_first_free(NULL);
   if (first_deallocated()) {
     first_deallocated()->set_next(head());
   }
 }
 
 
 void GlobalHandles::IterateStrongRoots(ObjectVisitor* v) {
   // Traversal of global handles marked as NORMAL.
-  for (Node* current = head_; current != NULL; current = current->next()) {
+  for (Node* current = v8_context()->global_handles_data_.head_;
+       current != NULL;
+       current = current->next()) {
     if (current->state_ == Node::NORMAL) {
       v->VisitPointer(&current->object_);
     }
   }
 }
 
 
 void GlobalHandles::IterateAllRoots(ObjectVisitor* v) {
-  for (Node* current = head_; current != NULL; current = current->next()) {
+  for (Node* current = v8_context()->global_handles_data_.head_;
+       current != NULL;
+       current = current->next()) {
     if (current->state_ != Node::DESTROYED) {
       v->VisitPointer(&current->object_);
     }
   }
 }
 
 
 void GlobalHandles::TearDown() {
   // Reset all the lists.
   set_head(NULL);
   set_first_free(NULL);
   set_first_deallocated(NULL);
-  pool_.Release();
+  v8_context()->global_handles_data_.private_data_.pool_.Release();
 }
 
+GlobalHandlesData::GlobalHandlesData()
+  :number_of_weak_handles_(0),
+  number_of_global_object_weak_handles_(0),
+  head_(NULL),
+  first_free_(NULL),
+  private_data_(*new GlobalHandlesPrivateData()),
+  first_deallocated_(NULL) {
+}
 
-int GlobalHandles::number_of_weak_handles_ = 0;
-int GlobalHandles::number_of_global_object_weak_handles_ = 0;
-
-GlobalHandles::Node* GlobalHandles::head_ = NULL;
-GlobalHandles::Node* GlobalHandles::first_free_ = NULL;
-GlobalHandles::Node* GlobalHandles::first_deallocated_ = NULL;
+GlobalHandlesData::~GlobalHandlesData() {
+  delete &private_data_;
+}
 
 void GlobalHandles::RecordStats(HeapStats* stats) {
   *stats->global_handle_count = 0;
   *stats->weak_global_handle_count = 0;
   *stats->pending_global_handle_count = 0;
   *stats->near_death_global_handle_count = 0;
   *stats->destroyed_global_handle_count = 0;
-  for (Node* current = head_; current != NULL; current = current->next()) {
+  for (Node* current = v8_context()->global_handles_data_.head_;
+    current != NULL; current = current->next()) {
     *stats->global_handle_count += 1;
     if (current->state_ == Node::WEAK) {
       *stats->weak_global_handle_count += 1;
     } else if (current->state_ == Node::PENDING) {
       *stats->pending_global_handle_count += 1;
     } else if (current->state_ == Node::NEAR_DEATH) {
       *stats->near_death_global_handle_count += 1;
     } else if (current->state_ == Node::DESTROYED) {
       *stats->destroyed_global_handle_count += 1;
     }
   }
 }
 
 #ifdef DEBUG
 
 void GlobalHandles::PrintStats() {
   int total = 0;
   int weak = 0;
   int pending = 0;
   int near_death = 0;
   int destroyed = 0;
 
-  for (Node* current = head_; current != NULL; current = current->next()) {
+  for (Node* current = v8_context()->global_handles_data_.head_;
+       current != NULL;
+       current = current->next()) {
     total++;
     if (current->state_ == Node::WEAK) weak++;
     if (current->state_ == Node::PENDING) pending++;
     if (current->state_ == Node::NEAR_DEATH) near_death++;
     if (current->state_ == Node::DESTROYED) destroyed++;
   }
 
   PrintF("Global Handle Statistics:\n");
   PrintF("  allocated memory = %dB\n", sizeof(Node) * total);
   PrintF("  # weak       = %d\n", weak);
   PrintF("  # pending    = %d\n", pending);
   PrintF("  # near_death = %d\n", near_death);
   PrintF("  # destroyed  = %d\n", destroyed);
   PrintF("  # total      = %d\n", total);
 }
 
 void GlobalHandles::Print() {
   PrintF("Global handles:\n");
-  for (Node* current = head_; current != NULL; current = current->next()) {
+  for (Node* current = v8_context()->global_handles_data_.head_;
+       current != NULL;
+       current = current->next()) {
     PrintF("  handle %p to %p (weak=%d)\n", current->handle().location(),
            *current->handle(), current->state_ == Node::WEAK);
   }
 }
 
 #endif
 
 List<ObjectGroup*>* GlobalHandles::ObjectGroups() {
   // Lazily initialize the list to avoid startup time static constructors.
   static List<ObjectGroup*> groups(4);
@@ skipping 11 matching lines @@
 void GlobalHandles::RemoveObjectGroups() {
   List<ObjectGroup*>* object_groups = ObjectGroups();
   for (int i = 0; i< object_groups->length(); i++) {
     delete object_groups->at(i);
   }
   object_groups->Clear();
 }
 
 
 } }  // namespace v8::internal