Remove background finalization.

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 RUNTIME_VM_DART_API_STATE_H_
 #define RUNTIME_VM_DART_API_STATE_H_
 
 #include "include/dart_api.h"
 
 #include "platform/utils.h"
 #include "vm/bitfield.h"
 #include "vm/dart_api_impl.h"
 #include "vm/flags.h"
 #include "vm/growable_array.h"
 #include "vm/handles.h"
 #include "vm/object.h"
 #include "vm/os.h"
 #include "vm/os_thread.h"
 #include "vm/raw_object.h"
 #include "vm/thread_pool.h"
 #include "vm/visitor.h"
 #include "vm/weak_table.h"
 
 #include "vm/handles_impl.h"
 
 namespace dart {
 
-class FinalizablePersistentHandle;
-typedef MallocGrowableArray<FinalizablePersistentHandle*> FinalizationQueue;
-
-
-class BackgroundFinalizer : public ThreadPool::Task {
- public:
-  BackgroundFinalizer(Isolate* isolate, FinalizationQueue* queue);
-  virtual ~BackgroundFinalizer() {}
-
-  void Run();
-
- private:
-  Isolate* isolate_;
-  FinalizationQueue* queue_;
-
-  DISALLOW_IMPLICIT_CONSTRUCTORS(BackgroundFinalizer);
-};
-
-
 // Implementation of Zone support for very fast allocation of small chunks
 // of memory. The chunks cannot be deallocated individually, but instead
 // zones support deallocating all chunks in one fast operation when the
 // scope is exited.
 class ApiZone {
  public:
   // Create an empty zone.
   ApiZone() : zone_() {
     Thread* thread = Thread::Current();
     Zone* zone = thread != NULL ? thread->zone() : NULL;
@@ skipping 180 matching lines @@
   void SetExternalSize(intptr_t size, Isolate* isolate) {
     ASSERT(size >= 0);
     set_external_size(size);
     if (SpaceForExternal() == Heap::kNew) {
       SetExternalNewSpaceBit();
     }
     isolate->heap()->AllocateExternal(external_size(), SpaceForExternal());
   }
 
   // Called when the referent becomes unreachable.
-  void UpdateUnreachable(Isolate* isolate, FinalizationQueue* queue) {
-    if (is_queued_for_finalization()) {
-      return;
-    }
+  void UpdateUnreachable(Isolate* isolate) {
     EnsureFreeExternal(isolate);
-    if (queue == NULL) {
-      Finalize(isolate, this);
-    } else {
-      MarkForFinalization();
-      queue->Add(this);
-      set_is_queued_for_finalization(true);
-    }
+    Finalize(isolate, this);
   }
 
   // Called when the referent has moved, potentially between generations.
   void UpdateRelocated(Isolate* isolate) {
     if (IsSetNewSpaceBit() && (SpaceForExternal() == Heap::kOld)) {
       isolate->heap()->PromoteExternal(external_size());
       ClearExternalNewSpaceBit();
     }
   }
 
   // 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);
   }
 
   static FinalizablePersistentHandle* Cast(Dart_WeakPersistentHandle handle);
 
  private:
   enum {
     kExternalNewSpaceBit = 0,
-    kQueuedForFinalizationBit = 1,
-    kExternalSizeBits = 2,
-    kExternalSizeBitsSize = (kBitsPerWord - 2),
+    kExternalSizeBits = 1,
+    kExternalSizeBitsSize = (kBitsPerWord - 1),
   };
 
   // This part of external_data_ is the number of externally allocated bytes.
   class ExternalSizeInWordsBits : public BitField<uword,
                                                   intptr_t,
                                                   kExternalSizeBits,
                                                   kExternalSizeBitsSize> {};
   // 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<uword, bool, kExternalNewSpaceBit, 1> {};
-  class QueuedForFinalizationBit
-      : public BitField<uword, bool, kQueuedForFinalizationBit, 1> {};
 
   friend class FinalizablePersistentHandles;
 
   FinalizablePersistentHandle()
       : raw_(NULL), peer_(NULL), external_data_(0), callback_(NULL) {}
   ~FinalizablePersistentHandle() {}
 
   static void Finalize(Isolate* isolate, FinalizablePersistentHandle* handle);
 
   // Overload the raw_ field as a next pointer when adding freed
@@ skipping 10 matching lines @@
     SetNext(free_list);
   }
 
   void Clear() {
     raw_ = Object::null();
     peer_ = NULL;
     external_data_ = 0;
     callback_ = NULL;
   }
 
-  void MarkForFinalization() {
-    raw_ = Object::null();
-    ASSERT(callback_ != NULL);
-  }
-
   void set_raw(RawObject* raw) { raw_ = raw; }
   void set_raw(const LocalHandle& ref) { raw_ = ref.raw(); }
   void set_raw(const Object& object) { raw_ = object.raw(); }
 
   void set_peer(void* peer) { peer_ = peer; }
 
   void set_callback(Dart_WeakPersistentHandleFinalizer callback) {
     callback_ = callback;
   }
 
   void set_external_size(intptr_t size) {
     intptr_t size_in_words = Utils::RoundUp(size, kObjectAlignment) / kWordSize;
     ASSERT(ExternalSizeInWordsBits::is_valid(size_in_words));
     external_data_ =
         ExternalSizeInWordsBits::update(size_in_words, external_data_);
   }
 
-  bool is_queued_for_finalization() const {
-    return QueuedForFinalizationBit::decode(external_data_);
-  }
-  void set_is_queued_for_finalization(bool value) {
-    external_data_ = QueuedForFinalizationBit::update(value, external_data_);
-  }
-
   bool IsSetNewSpaceBit() const {
     return ExternalNewSpaceBit::decode(external_data_);
   }
 
   void SetExternalNewSpaceBit() {
     external_data_ = ExternalNewSpaceBit::update(true, external_data_);
   }
 
   void ClearExternalNewSpaceBit() {
     external_data_ = ExternalNewSpaceBit::update(false, external_data_);
   }
 
   // Returns the space to charge for the external size.
   Heap::Space SpaceForExternal() const {
     // Non-heap and VM-heap objects count as old space here.
     return (raw_->IsHeapObject() && raw_->IsNewObject()) ? Heap::kNew
                                                          : Heap::kOld;
   }
 
-  friend class BackgroundFinalizer;
-
   RawObject* raw_;
   void* peer_;
   uword external_data_;
   Dart_WeakPersistentHandleFinalizer callback_;
 
   DISALLOW_ALLOCATION();  // Allocated through AllocateHandle methods.
   DISALLOW_COPY_AND_ASSIGN(FinalizablePersistentHandle);
 };
 
 
@@ skipping 152 matching lines @@
 static const int kOffsetOfRawPtrInFinalizablePersistentHandle = 0;
 class FinalizablePersistentHandles
     : Handles<kFinalizablePersistentHandleSizeInWords,
               kFinalizablePersistentHandlesPerChunk,
               kOffsetOfRawPtrInFinalizablePersistentHandle> {
  public:
   FinalizablePersistentHandles()
       : Handles<kFinalizablePersistentHandleSizeInWords,
                 kFinalizablePersistentHandlesPerChunk,
                 kOffsetOfRawPtrInFinalizablePersistentHandle>(),
-        free_list_(NULL),
-        mutex_(new Mutex()) {}
+        free_list_(NULL) {}
   ~FinalizablePersistentHandles() {
     free_list_ = NULL;
-    delete mutex_;
-    mutex_ = NULL;
   }
 
   // Accessors.
   FinalizablePersistentHandle* free_list() const { return free_list_; }
   void set_free_list(FinalizablePersistentHandle* value) { free_list_ = value; }
 
   // Visit all handles stored in the various handle blocks.
   void VisitHandles(HandleVisitor* visitor) {
     Handles<kFinalizablePersistentHandleSizeInWords,
             kFinalizablePersistentHandlesPerChunk,
             kOffsetOfRawPtrInFinalizablePersistentHandle>::Visit(visitor);
   }
 
   // Visit all object pointers stored in the various handles.
   void VisitObjectPointers(ObjectPointerVisitor* visitor) {
     Handles<kFinalizablePersistentHandleSizeInWords,
             kFinalizablePersistentHandlesPerChunk,
             kOffsetOfRawPtrInFinalizablePersistentHandle>::
         VisitObjectPointers(visitor);
   }
 
   // Allocates a persistent handle, these have to be destroyed explicitly
   // by calling FreeHandle.
   FinalizablePersistentHandle* AllocateHandle() {
     FinalizablePersistentHandle* handle;
-    {
-      MutexLocker ml(mutex_);
-      if (free_list_ != NULL) {
-        handle = free_list_;
-        free_list_ = handle->Next();
-        handle->set_raw(Object::null());
-        return handle;
-      }
+    if (free_list_ != NULL) {
+      handle = free_list_;
+      free_list_ = handle->Next();
+      handle->set_raw(Object::null());
+      return handle;
     }
 
     handle =
         reinterpret_cast<FinalizablePersistentHandle*>(AllocateScopedHandle());
     handle->Clear();
     return handle;
   }
 
   void FreeHandle(FinalizablePersistentHandle* handle) {
-    MutexLocker ml(mutex_);
     handle->FreeHandle(free_list());
     set_free_list(handle);
   }
 
   // Validate if passed in handle is a Persistent Handle.
   bool IsValidHandle(Dart_WeakPersistentHandle object) const {
-    MutexLocker ml(mutex_);
     return IsValidScopedHandle(reinterpret_cast<uword>(object));
   }
 
   bool IsFreeHandle(Dart_WeakPersistentHandle object) const {
-    MutexLocker ml(mutex_);
     FinalizablePersistentHandle* handle = free_list_;
     while (handle != NULL) {
       if (handle == reinterpret_cast<FinalizablePersistentHandle*>(object)) {
         return true;
       }
       handle = handle->Next();
     }
     return false;
   }
 
   // Returns a count of active handles (used for testing purposes).
   int CountHandles() const { return CountScopedHandles(); }
 
  private:
   FinalizablePersistentHandle* free_list_;
-  Mutex* mutex_;
   DISALLOW_COPY_AND_ASSIGN(FinalizablePersistentHandles);
 };
 
 
 // Structure used for the implementation of local scopes used in dart_api.
 // These local scopes manage handles and memory allocated in the scope.
 class ApiLocalScope {
  public:
   ApiLocalScope(ApiLocalScope* previous, uword stack_marker)
       : previous_(previous), stack_marker_(stack_marker) {}
@@ skipping 218 matching lines @@
     void* peer,
     Dart_WeakPersistentHandleFinalizer callback,
     intptr_t external_size) {
   ApiState* state = isolate->api_state();
   ASSERT(state != NULL);
   FinalizablePersistentHandle* ref =
       state->weak_persistent_handles().AllocateHandle();
   ref->set_raw(object);
   ref->set_peer(peer);
   ref->set_callback(callback);
-  ref->set_is_queued_for_finalization(false);
   // This may trigger GC, so it must be called last.
   ref->SetExternalSize(external_size, isolate);
   return ref;
 }
 
 }  // namespace dart
 
 #endif  // RUNTIME_VM_DART_API_STATE_H_