Merge isolates to bleeding_edge.

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 17 matching lines @@
 #include "v8.h"
 
 #include "api.h"
 #include "global-handles.h"
 
 #include "vm-state-inl.h"
 
 namespace v8 {
 namespace internal {
 
+
+ObjectGroup::~ObjectGroup() {
+  if (info_ != NULL) info_->Dispose();
+}
+
+
 class GlobalHandles::Node : public Malloced {
  public:
 
   void Initialize(Object* object) {
     // Set the initial value of the handle.
     object_ = object;
     class_id_ = v8::HeapProfiler::kPersistentHandleNoClassId;
     state_  = NORMAL;
     parameter_or_next_free_.parameter = NULL;
     callback_ = NULL;
   }
 
   Node() {
     state_ = DESTROYED;
   }
 
   explicit Node(Object* object) {
     Initialize(object);
     // Initialize link structure.
     next_ = NULL;
   }
 
   ~Node() {
-    if (state_ != DESTROYED) Destroy();
+    if (state_ != DESTROYED) Destroy(Isolate::Current()->global_handles());
 #ifdef DEBUG
     // Zap the values for eager trapping.
     object_ = NULL;
     next_ = NULL;
     parameter_or_next_free_.next_free = NULL;
 #endif
   }
 
-  void Destroy() {
+  void Destroy(GlobalHandles* global_handles) {
     if (state_ == WEAK || IsNearDeath()) {
-      GlobalHandles::number_of_weak_handles_--;
+      global_handles->number_of_weak_handles_--;
       if (object_->IsJSGlobalObject()) {
-        GlobalHandles::number_of_global_object_weak_handles_--;
+        global_handles->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 10 matching lines @@
   // Returns a link from the handle.
   static Node* FromLocation(Object** location) {
     ASSERT(OFFSET_OF(Node, object_) == 0);
     return reinterpret_cast<Node*>(location);
   }
 
   // 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()));
+  void MakeWeak(GlobalHandles* global_handles, void* parameter,
+                WeakReferenceCallback callback) {
+    LOG(global_handles->isolate(),
+        HandleEvent("GlobalHandle::MakeWeak", handle().location()));
     ASSERT(state_ != DESTROYED);
     if (state_ != WEAK && !IsNearDeath()) {
-      GlobalHandles::number_of_weak_handles_++;
+      global_handles->number_of_weak_handles_++;
       if (object_->IsJSGlobalObject()) {
-        GlobalHandles::number_of_global_object_weak_handles_++;
+        global_handles->number_of_global_object_weak_handles_++;
       }
     }
     state_ = WEAK;
     set_parameter(parameter);
     callback_ = callback;
   }
 
-  void ClearWeakness() {
-    LOG(HandleEvent("GlobalHandle::ClearWeakness", handle().location()));
+  void ClearWeakness(GlobalHandles* global_handles) {
+    LOG(global_handles->isolate(),
+        HandleEvent("GlobalHandle::ClearWeakness", handle().location()));
     ASSERT(state_ != DESTROYED);
     if (state_ == WEAK || IsNearDeath()) {
-      GlobalHandles::number_of_weak_handles_--;
+      global_handles->number_of_weak_handles_--;
       if (object_->IsJSGlobalObject()) {
-        GlobalHandles::number_of_global_object_weak_handles_--;
+        global_handles->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 16 matching lines @@
     parameter_or_next_free_.parameter = parameter;
   }
   void* parameter() {
     ASSERT(state_ != DESTROYED);
     return parameter_or_next_free_.parameter;
   }
 
   // Returns the callback for this weak handle.
   WeakReferenceCallback callback() { return callback_; }
 
-  bool PostGarbageCollectionProcessing() {
+  bool PostGarbageCollectionProcessing(Isolate* isolate,
+                                       GlobalHandles* global_handles) {
     if (state_ != Node::PENDING) return false;
-    LOG(HandleEvent("GlobalHandle::Processing", handle().location()));
+    LOG(isolate, HandleEvent("GlobalHandle::Processing", handle().location()));
     WeakReferenceCallback func = callback();
     if (func == NULL) {
-      Destroy();
+      Destroy(global_handles);
       return false;
     }
     void* par = parameter();
     state_ = NEAR_DEATH;
     set_parameter(NULL);
 
     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());
+      global_handles->set_first_free(NULL);
+      if (global_handles->first_deallocated()) {
+        global_handles->first_deallocated()->set_next(global_handles->head());
       }
       // Check that we are not passing a finalized external string to
       // the callback.
       ASSERT(!object_->IsExternalAsciiString() ||
              ExternalAsciiString::cast(object_)->resource() != NULL);
       ASSERT(!object_->IsExternalTwoByteString() ||
              ExternalTwoByteString::cast(object_)->resource() != NULL);
       // Leaving V8.
-      VMState state(EXTERNAL);
+      VMState state(isolate, EXTERNAL);
       func(object, par);
     }
     // Absense of explicit cleanup or revival of weak handle
     // in most of the cases would lead to memory leak.
     ASSERT(state_ != NEAR_DEATH);
     return true;
   }
 
   // Place the handle address first to avoid offset computation.
   Object* object_;  // Storage for object pointer.
@@ skipping 22 matching lines @@
   } parameter_or_next_free_;
 
   // Linkage for the list.
   Node* next_;
 
  public:
   TRACK_MEMORY("GlobalHandles::Node")
 };
 
 
-class GlobalHandles::Pool BASE_EMBEDDED {
+class GlobalHandles::Pool {
   public:
     Pool() {
       current_ = new Chunk();
       current_->previous = NULL;
       next_ = current_->nodes;
       limit_ = current_->nodes + kNodesPerChunk;
     }
 
     ~Pool() {
       if (current_ != NULL) {
@@ skipping 37 matching lines @@
       limit_ = new_nodes + kNodesPerChunk;
       return new_nodes;
     }
 
     Chunk* current_;
     Node* next_;
     Node* limit_;
 };
 
 
-static GlobalHandles::Pool pool_;
+GlobalHandles::GlobalHandles(Isolate* isolate)
+    : isolate_(isolate),
+      number_of_weak_handles_(0),
+      number_of_global_object_weak_handles_(0),
+      head_(NULL),
+      first_free_(NULL),
+      first_deallocated_(NULL),
+      pool_(new Pool()),
+      post_gc_processing_count_(0),
+      object_groups_(4) {
+}
+
+
+GlobalHandles::~GlobalHandles() {
+  delete pool_;
+  pool_ = 0;
+}
 
 
 Handle<Object> GlobalHandles::Create(Object* value) {
-  Counters::global_handles.Increment();
+  isolate_->counters()->global_handles()->Increment();
   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 = pool_->Allocate();
     result->set_next(head());
     set_head(result);
   }
   result->Initialize(value);
   return result->handle();
 }
 
 
 void GlobalHandles::Destroy(Object** location) {
-  Counters::global_handles.Decrement();
+  isolate_->counters()->global_handles()->Decrement();
   if (location == NULL) return;
   Node* node = Node::FromLocation(location);
-  node->Destroy();
+  node->Destroy(this);
   // Link the destroyed.
   node->set_next_free(first_free());
   set_first_free(node);
 }
 
 
 void GlobalHandles::MakeWeak(Object** location, void* parameter,
                              WeakReferenceCallback callback) {
   ASSERT(callback != NULL);
-  Node::FromLocation(location)->MakeWeak(parameter, callback);
+  Node::FromLocation(location)->MakeWeak(this, parameter, callback);
 }
 
 
 void GlobalHandles::ClearWeakness(Object** location) {
-  Node::FromLocation(location)->ClearWeakness();
+  Node::FromLocation(location)->ClearWeakness(this);
 }
 
 
 bool GlobalHandles::IsNearDeath(Object** location) {
   return Node::FromLocation(location)->IsNearDeath();
 }
 
 
 bool GlobalHandles::IsWeak(Object** location) {
   return Node::FromLocation(location)->IsWeak();
@@ skipping 26 matching lines @@
     }
   }
 }
 
 
 void GlobalHandles::IdentifyWeakHandles(WeakSlotCallback f) {
   for (Node* current = 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()));
+        LOG(isolate_,
+            HandleEvent("GlobalHandle::Pending", current->handle().location()));
       }
     }
   }
 }
 
 
-int post_gc_processing_count = 0;
-
 bool 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;
+  ASSERT(isolate_->heap()->gc_state() == Heap::NOT_IN_GC);
+  const int initial_post_gc_processing_count = ++post_gc_processing_count_;
   bool next_gc_likely_to_collect_more = false;
   Node** p = &head_;
   while (*p != NULL) {
-    if ((*p)->PostGarbageCollectionProcessing()) {
-      if (initial_post_gc_processing_count != post_gc_processing_count) {
+    if ((*p)->PostGarbageCollectionProcessing(isolate_, this)) {
+      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;
       }
     }
     if ((*p)->state_ == Node::DESTROYED) {
       // Delete the link.
       Node* node = *p;
@@ skipping 44 matching lines @@
     }
   }
 }
 
 
 void GlobalHandles::TearDown() {
   // Reset all the lists.
   set_head(NULL);
   set_first_free(NULL);
   set_first_deallocated(NULL);
-  pool_.Release();
+  pool_->Release();
 }
 
 
-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;
-
 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()) {
     *stats->global_handle_count += 1;
     if (current->state_ == Node::WEAK) {
       *stats->weak_global_handle_count += 1;
@@ skipping 38 matching lines @@
   for (Node* current = head_; current != NULL; current = current->next()) {
     PrintF("  handle %p to %p (weak=%d)\n",
            reinterpret_cast<void*>(current->handle().location()),
            reinterpret_cast<void*>(*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);
-  return &groups;
-}
 
 
 void GlobalHandles::AddObjectGroup(Object*** handles,
                                    size_t length,
                                    v8::RetainedObjectInfo* info) {
   ObjectGroup* new_entry = new ObjectGroup(length, info);
   for (size_t i = 0; i < length; ++i) {
     new_entry->objects_.Add(handles[i]);
   }
-  ObjectGroups()->Add(new_entry);
-}
-
-
-List<ImplicitRefGroup*>* GlobalHandles::ImplicitRefGroups() {
-  // Lazily initialize the list to avoid startup time static constructors.
-  static List<ImplicitRefGroup*> groups(4);
-  return &groups;
+  object_groups_.Add(new_entry);
 }
 
 
 void GlobalHandles::AddImplicitReferences(HeapObject* parent,
                                           Object*** children,
                                           size_t length) {
   ImplicitRefGroup* new_entry = new ImplicitRefGroup(parent, length);
   for (size_t i = 0; i < length; ++i) {
     new_entry->children_.Add(children[i]);
   }
-  ImplicitRefGroups()->Add(new_entry);
+  implicit_ref_groups_.Add(new_entry);
 }
 
 
 void GlobalHandles::RemoveObjectGroups() {
-  List<ObjectGroup*>* object_groups = ObjectGroups();
-  for (int i = 0; i< object_groups->length(); i++) {
-    delete object_groups->at(i);
+  for (int i = 0; i < object_groups_.length(); i++) {
+    delete object_groups_.at(i);
   }
-  object_groups->Clear();
+  object_groups_.Clear();
 }
 
 
 void GlobalHandles::RemoveImplicitRefGroups() {
-  List<ImplicitRefGroup*>* ref_groups = ImplicitRefGroups();
-  for (int i = 0; i< ref_groups->length(); i++) {
-    delete ref_groups->at(i);
+  for (int i = 0; i < implicit_ref_groups_.length(); i++) {
+    delete implicit_ref_groups_.at(i);
   }
-  ref_groups->Clear();
+  implicit_ref_groups_.Clear();
 }
 
 
 } }  // namespace v8::internal