Remove support for object grouping during Garbage Collection

runtime/vm/dart_api_state.h

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #ifndef VM_DART_API_STATE_H_
 #define VM_DART_API_STATE_H_
 
 #include "include/dart_api.h"
 
 #include "platform/utils.h"
@@ skipping 185 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(PersistentHandle);
 };
 
 
 // Implementation of persistent handles which are handed out through the
 // dart API.
 class FinalizablePersistentHandle {
  public:
   static FinalizablePersistentHandle* New(
       Isolate* isolate,
-      bool is_prologue,
       const Object& object,
       void* peer,
       Dart_WeakPersistentHandleFinalizer callback,
       intptr_t external_size);
 
   // Accessors.
   RawObject* raw() const { return raw_; }
   RawObject** raw_addr() { return &raw_; }
   static intptr_t raw_offset() {
     return OFFSET_OF(FinalizablePersistentHandle, raw_);
@@ skipping 27 matching lines @@
     }
   }
 
   // Idempotent. Called when the handle is explicitly deleted or the
   // referent becomes unreachable.
   void EnsureFreeExternal(Isolate* isolate) {
     isolate->heap()->FreeExternal(external_size(), SpaceForExternal());
     set_external_size(0);
   }
 
-  bool IsPrologueWeakPersistent() {
-    return PrologueWeakBit::decode(external_data_);
-  }
-
-  void SetPrologueWeakPersistent(bool value) {
-    external_data_ = PrologueWeakBit::update(value, external_data_);
-  }
-
   static FinalizablePersistentHandle* Cast(Dart_WeakPersistentHandle handle);
 
  private:
   enum {
     kExternalNewSpaceBit = 0,
-    kPrologueWeakBit = 1,
-    kExternalSizeBits = 2,
-    kExternalSizeBitsSize = (kBitsPerWord - 2),
+    kExternalSizeBits = 1,
+    kExternalSizeBitsSize = (kBitsPerWord - 1),
   };
 
   // This part of external_data_ is the number of externally allocated bytes.
   // TODO(koda): Measure size in words instead.
   class ExternalSizeBits : public BitField<intptr_t,
                                            kExternalSizeBits,
                                            kExternalSizeBitsSize> {};  // NOLINT
   // This bit of external_data_ is true if the referent was created in new
   // space and UpdateRelocated has not yet detected any promotion.
   class ExternalNewSpaceBit : public BitField<bool, kExternalNewSpaceBit, 1> {};
-  // This bit is used to indicate that it is a prologue weak persistent handle.
-  class PrologueWeakBit : public BitField<bool, kPrologueWeakBit, 1> {};
 
   friend class FinalizablePersistentHandles;
 
   FinalizablePersistentHandle()
       : raw_(NULL),
         peer_(NULL),
         external_data_(0),
         callback_(NULL) { }
   ~FinalizablePersistentHandle() { }
 
@@ skipping 374 matching lines @@
           initial_capacity,
           ApiNativeScope::Current()->zone()) {}
   ApiGrowableArray()
       : BaseGrowableArray<T, ValueObject>(
           ApiNativeScope::Current()->zone()) {}
   ApiGrowableArray(intptr_t initial_capacity, Zone* zone)
       : BaseGrowableArray<T, ValueObject>(initial_capacity, zone) {}
 };
 
 
-// Forward declarations.
-class WeakReferenceSetBuilder;
-class WeakReferenceSet;
-
-
 // Implementation of the API State used in dart api for maintaining
 // local scopes, persistent handles etc. These are setup on a per isolate
 // basis and destroyed when the isolate is shutdown.
 class ApiState {
  public:
   ApiState() : persistent_handles_(),
                weak_persistent_handles_(),
-               prologue_weak_persistent_handles_(),
                reusable_scope_(NULL),
                top_scope_(NULL),
-               delayed_weak_reference_sets_(NULL),
                null_(NULL),
                true_(NULL),
                false_(NULL),
                acquired_error_(NULL) {}
   ~ApiState() {
     while (top_scope_ != NULL) {
       ApiLocalScope* scope = top_scope_;
       top_scope_ = top_scope_->previous();
       delete scope;
     }
@@ skipping 23 matching lines @@
   }
   ApiLocalScope* top_scope() const { return top_scope_; }
   void set_top_scope(ApiLocalScope* value) { top_scope_ = value; }
 
   PersistentHandles& persistent_handles() { return persistent_handles_; }
 
   FinalizablePersistentHandles& weak_persistent_handles() {
     return weak_persistent_handles_;
   }
 
-  FinalizablePersistentHandles& prologue_weak_persistent_handles() {
-    return prologue_weak_persistent_handles_;
-  }
-
-  WeakReferenceSet* delayed_weak_reference_sets() {
-    return delayed_weak_reference_sets_;
-  }
-  void set_delayed_weak_reference_sets(WeakReferenceSet* reference_set) {
-    delayed_weak_reference_sets_ = reference_set;
-  }
-
   void UnwindScopes(uword stack_marker) {
     // Unwind all scopes using the same stack_marker, i.e. all scopes allocated
     // under the same top_exit_frame_info.
     while (top_scope_ != NULL &&
            top_scope_->stack_marker() != 0 &&
            top_scope_->stack_marker() == stack_marker) {
       ApiLocalScope* scope = top_scope_;
       top_scope_ = top_scope_->previous();
       delete scope;
     }
   }
 
-  void VisitObjectPointers(ObjectPointerVisitor* visitor,
-                           bool visit_prologue_weak_handles) {
+  void VisitObjectPointers(ObjectPointerVisitor* visitor) {
     ApiLocalScope* scope = top_scope_;
     while (scope != NULL) {
       scope->local_handles()->VisitObjectPointers(visitor);
       scope = scope->previous();
     }
     persistent_handles().VisitObjectPointers(visitor);
-    if (visit_prologue_weak_handles) {
-      prologue_weak_persistent_handles().VisitObjectPointers(visitor);
-    }
   }
 
-  void VisitWeakHandles(HandleVisitor* visitor,
-                        bool visit_prologue_weak_handles) {
+  void VisitWeakHandles(HandleVisitor* visitor) {
     weak_persistent_handles().VisitHandles(visitor);
-    if (visit_prologue_weak_handles) {
-      prologue_weak_persistent_handles().VisitHandles(visitor);
-    }
-  }
-
-  void VisitPrologueWeakHandles(HandleVisitor* visitor) {
-    prologue_weak_persistent_handles().VisitHandles(visitor);
   }
 
   bool IsValidLocalHandle(Dart_Handle object) const {
     ApiLocalScope* scope = top_scope_;
     while (scope != NULL) {
       if (scope->local_handles()->IsValidHandle(object)) {
         return true;
       }
       scope = scope->previous();
     }
     return false;
   }
 
   bool IsValidPersistentHandle(Dart_PersistentHandle object) const {
     return persistent_handles_.IsValidHandle(object);
   }
 
   bool IsValidWeakPersistentHandle(Dart_WeakPersistentHandle object) const {
     return weak_persistent_handles_.IsValidHandle(object);
   }
 
-  bool IsValidPrologueWeakPersistentHandle(
-      Dart_WeakPersistentHandle object) const {
-    return prologue_weak_persistent_handles_.IsValidHandle(object);
-  }
-
   bool IsProtectedHandle(PersistentHandle* object) const {
     if (object == NULL) return false;
     return object == null_ || object == true_ || object == false_;
   }
 
   int CountLocalHandles() const {
     int total = 0;
     ApiLocalScope* scope = top_scope_;
     while (scope != NULL) {
       total += scope->local_handles()->CountHandles();
@@ skipping 21 matching lines @@
                     "please release them using Dart_TypedDataReleaseData."));
     acquired_error_ = persistent_handles().AllocateHandle();
     acquired_error_->set_raw(ApiError::New(msg));
   }
 
   PersistentHandle* AcquiredError() const {
     ASSERT(acquired_error_ != NULL);
     return acquired_error_;
   }
 
-  WeakReferenceSetBuilder* NewWeakReferenceSetBuilder();
-
-  void DelayWeakReferenceSet(WeakReferenceSet* reference_set);
-
   WeakTable* acquired_table() { return &acquired_table_; }
 
  private:
   PersistentHandles persistent_handles_;
   FinalizablePersistentHandles weak_persistent_handles_;
-  FinalizablePersistentHandles prologue_weak_persistent_handles_;
   ApiLocalScope* reusable_scope_;
   ApiLocalScope* top_scope_;
-  WeakReferenceSet* delayed_weak_reference_sets_;
   WeakTable acquired_table_;
 
   // Persistent handles to important objects.
   PersistentHandle* null_;
   PersistentHandle* true_;
   PersistentHandle* false_;
   PersistentHandle* acquired_error_;
 
   DISALLOW_COPY_AND_ASSIGN(ApiState);
 };
 
 
-class WeakReferenceSet {
- public:
-  explicit WeakReferenceSet(Zone* zone)
-      : next_(NULL),
-        keys_(1, zone),
-        values_(1, zone) {
-  }
-  ~WeakReferenceSet() {}
-
-  WeakReferenceSet* next() const { return next_; }
-
-  intptr_t num_keys() const { return keys_.length(); }
-  RawObject** get_key(intptr_t i) {
-    ASSERT(i >= 0);
-    ASSERT(i < num_keys());
-    FinalizablePersistentHandle* ref =
-        FinalizablePersistentHandle::Cast(keys_[i]);
-    return ref->raw_addr();
-  }
-
-  intptr_t num_values() const { return values_.length(); }
-  RawObject** get_value(intptr_t i) {
-    ASSERT(i >= 0);
-    ASSERT(i < num_values());
-    FinalizablePersistentHandle* ref =
-        FinalizablePersistentHandle::Cast(values_[i]);
-    return ref->raw_addr();
-  }
-
-  bool SingletonKeyEqualsValue() const {
-    ASSERT((num_keys() == 1) && (num_values() == 1));
-    return (keys_[0] == values_[0]);
-  }
-
-  void Append(Dart_WeakPersistentHandle key, Dart_WeakPersistentHandle value) {
-    keys_.Add(key);
-    values_.Add(value);
-  }
-
-  void AppendKey(Dart_WeakPersistentHandle key) {
-    keys_.Add(key);
-  }
-
-  void AppendValue(Dart_WeakPersistentHandle value) {
-    values_.Add(value);
-  }
-
-  static WeakReferenceSet* Pop(WeakReferenceSet** queue) {
-    ASSERT(queue != NULL);
-    WeakReferenceSet* head = *queue;
-    if (head != NULL) {
-      *queue = head->next();
-      head->next_ = NULL;
-    }
-    return head;
-  }
-
-  static void Push(WeakReferenceSet* reference_set, WeakReferenceSet** queue) {
-    ASSERT(reference_set != NULL);
-    ASSERT(queue != NULL);
-    reference_set->next_ = *queue;
-    *queue = reference_set;
-  }
-
-  void* operator new(uword size, Zone* zone) {
-    return reinterpret_cast<void*>(zone->AllocUnsafe(size));
-  }
-
-  // Disallow explicit deallocation of WeakReferenceSet.
-  void operator delete(void* pointer) { UNREACHABLE(); }
-
- private:
-  WeakReferenceSet* next_;
-  ApiGrowableArray<Dart_WeakPersistentHandle> keys_;
-  ApiGrowableArray<Dart_WeakPersistentHandle> values_;
-
-  DISALLOW_COPY_AND_ASSIGN(WeakReferenceSet);
-};
-
-
-class WeakReferenceSetBuilder {
- public:
-  ApiState* api_state() const {
-    return api_state_;
-  }
-
-  WeakReferenceSet* NewWeakReferenceSet() {
-    return new (zone_) WeakReferenceSet(zone_);
-  }
-
- private:
-  explicit WeakReferenceSetBuilder(ApiState* api_state)
-      : api_state_(api_state),
-        zone_(api_state->top_scope()->zone()) {
-  }
-
-  ApiState* api_state_;
-  Zone* zone_;
-
-  friend class ApiState;
-  DISALLOW_IMPLICIT_CONSTRUCTORS(WeakReferenceSetBuilder);
-};
-
-
 inline FinalizablePersistentHandle* FinalizablePersistentHandle::New(
     Isolate* isolate,
-    bool is_prologue,
     const Object& object,
     void* peer,
     Dart_WeakPersistentHandleFinalizer callback,
     intptr_t external_size) {
   ApiState* state = isolate->api_state();
   ASSERT(state != NULL);
-  FinalizablePersistentHandle* ref = is_prologue ?
-      state->prologue_weak_persistent_handles().AllocateHandle() :
+  FinalizablePersistentHandle* ref =
       state->weak_persistent_handles().AllocateHandle();
-  ref->SetPrologueWeakPersistent(is_prologue);
   ref->set_raw(object);
   ref->set_peer(peer);
   ref->set_callback(callback);
   // This may trigger GC, so it must be called last.
   ref->SetExternalSize(external_size, isolate);
   return ref;
 }
 
 }  // namespace dart
 
 #endif  // VM_DART_API_STATE_H_