Background finalization.

runtime/vm/heap.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_HEAP_H_
 #define VM_HEAP_H_
 
 #include "platform/assert.h"
 #include "vm/allocation.h"
 #include "vm/flags.h"
 #include "vm/globals.h"
 #include "vm/pages.h"
 #include "vm/scavenger.h"
 #include "vm/spaces.h"
 #include "vm/verifier.h"
 #include "vm/weak_table.h"
+#include "vm/thread_pool.h"

[siva, 2016/06/02 20:18:05]

Why is thread_pool.h included here?

[rmacnak, 2016/06/03 01:08:31]

Leftover, removed.

 
 namespace dart {
 
 // Forward declarations.
 class Isolate;
 class ObjectPointerVisitor;
 class ObjectSet;
 class ServiceEvent;
 class TimelineEventScope;
 class VirtualMemory;
+class FinalizablePersistentHandle;

[siva, 2016/06/02 20:18:05]

Is this forward declaration necessary

+
 
 class Heap {
  public:
   enum Space {
     kNew,
     kOld,
     kCode,
     // TODO(koda): Harmonize all old-space allocation and get rid of this.
     kPretenured,
   };
@@ skipping 212 matching lines @@
   // The heap map contains the sizes and class ids for the objects in each page.
   void PrintHeapMapToJSONStream(Isolate* isolate, JSONStream* stream) {
     return old_space_.PrintHeapMapToJSONStream(isolate, stream);
   }
 
   Isolate* isolate() const { return isolate_; }
 
   Monitor* barrier() const { return barrier_; }
   Monitor* barrier_done() const { return barrier_done_; }
 
+  Monitor* finalization_tasks_lock() const { return finalization_tasks_lock_; }
+  intptr_t finalization_tasks() const { return finalization_tasks_; }
+  void set_finalization_tasks(intptr_t count) { finalization_tasks_ = count; }
+
   bool ShouldPretenure(intptr_t class_id) const;
 
   void SetupExternalPage(void* pointer, uword size, bool is_executable) {
     old_space_.SetupExternalPage(pointer, size, is_executable);
   }
 
  private:
   class GCStats : public ValueObject {
    public:
     GCStats() {}
@@ skipping 77 matching lines @@
   // The different spaces used for allocation.
   ALIGN8 Scavenger new_space_;
   PageSpace old_space_;
 
   WeakTable* new_weak_tables_[kNumWeakSelectors];
   WeakTable* old_weak_tables_[kNumWeakSelectors];
 
   Monitor* barrier_;
   Monitor* barrier_done_;
 
+  Monitor* finalization_tasks_lock_;
+  intptr_t finalization_tasks_;
+
   // GC stats collection.
   GCStats stats_;
 
   // This heap is in read-only mode: No allocation is allowed.
   bool read_only_;
 
   // GC on the heap is in progress.
   Monitor gc_in_progress_monitor_;
   bool gc_new_space_in_progress_;
   bool gc_old_space_in_progress_;
@@ skipping 34 matching lines @@
 // Note: During this scope, the code pages are non-executable.
 class WritableVMIsolateScope : StackResource {
  public:
   explicit WritableVMIsolateScope(Thread* thread);
   ~WritableVMIsolateScope();
 };
 
 }  // namespace dart
 
 #endif  // VM_HEAP_H_