- Add a separate step to finalize the VM isolate explicitly.

runtime/vm/dart.cc

 // Copyright (c) 2013, 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.
 
 #include "vm/dart.h"
 
 #include "vm/code_observers.h"
 #include "vm/cpu.h"
 #include "vm/dart_api_state.h"
 #include "vm/dart_entry.h"
@@ skipping 27 matching lines @@
             "e.g: --old_gen_heap_size=1024 allows up to 1024MB old gen heap");
 
 DECLARE_FLAG(bool, print_class_table);
 DECLARE_FLAG(bool, trace_isolates);
 
 Isolate* Dart::vm_isolate_ = NULL;
 ThreadPool* Dart::thread_pool_ = NULL;
 DebugInfo* Dart::pprof_symbol_generator_ = NULL;
 ReadOnlyHandles* Dart::predefined_handles_ = NULL;
 
-// An object visitor which will mark all visited objects. This is used to
-// premark all objects in the vm_isolate_ heap.
-class PremarkingVisitor : public ObjectVisitor {
- public:
-  explicit PremarkingVisitor(Isolate* isolate) : ObjectVisitor(isolate) {}
-
-  void VisitObject(RawObject* obj) {
-    // RawInstruction objects are premarked on allocation.
-    if (!obj->IsMarked()) {
-      obj->SetMarkBit();
-    }
-  }
-};
-
-
 // Structure for managing read-only global handles allocation used for
 // creating global read-only handles that are pre created and initialized
 // for use across all isolates. Having these global pre created handles
 // stored in the vm isolate ensures that we don't constantly create and
 // destroy handles for read-only objects referred in the VM code
 // (e.g: symbols, null object, empty array etc.)
 // The ReadOnlyHandles C++ Wrapper around VMHandles which is a ValueObject is
 // to ensure that the handles area is not trashed by automatic running of C++
 // static destructors when 'exit()" is called by any isolate. There might be
 // other isolates running at the same time and trashing the handles area will
@@ skipping 51 matching lines @@
     ASSERT(vm_isolate_ == NULL);
     ASSERT(Flags::Initialized());
     vm_isolate_ = Isolate::Init("vm-isolate");
     StackZone zone(vm_isolate_);
     HandleScope handle_scope(vm_isolate_);
     Heap::Init(vm_isolate_,
                0,  // New gen size 0; VM isolate should only allocate in old.
                FLAG_old_gen_heap_size * MBInWords);
     ObjectStore::Init(vm_isolate_);
     TargetCPUFeatures::InitOnce();
-    Object::InitOnce();
+    Object::InitOnce(vm_isolate_);
     ArgumentsDescriptor::InitOnce();
     StubCode::InitOnce();
     Symbols::InitOnce(vm_isolate_);
     Scanner::InitOnce();
 #if defined(TARGET_ARCH_IA32) || defined(TARGET_ARCH_X64)
     // Dart VM requires at least SSE2.
     if (!TargetCPUFeatures::sse2_supported()) {
       return "SSE2 is required.";
     }
 #endif
-    PremarkingVisitor premarker(vm_isolate_);
-    vm_isolate_->heap()->WriteProtect(false);
-    ASSERT(vm_isolate_->heap()->UsedInWords(Heap::kNew) == 0);
-    vm_isolate_->heap()->IterateOldObjects(&premarker);
-    vm_isolate_->heap()->WriteProtect(true);
+    Object::FinalizeVMIsolate(vm_isolate_);
   }
   // There is a planned and known asymmetry here: We enter one scope for the VM
   // isolate so that we can allocate the "persistent" scoped handles for the
   // predefined API values (such as Dart_True, Dart_False and Dart_Null).
   Dart_EnterScope();
   Api::InitHandles();
 
   Isolate::SetCurrent(NULL);  // Unregister the VM isolate from this thread.
   Isolate::SetCreateCallback(create);
   Isolate::SetServiceCreateCallback(service_create);
@@ skipping 149 matching lines @@
   return predefined_handles_->handles_.AllocateScopedHandle();
 }
 
 
 bool Dart::IsReadOnlyHandle(uword address) {
   ASSERT(predefined_handles_ != NULL);
   return predefined_handles_->handles_.IsValidScopedHandle(address);
 }
 
 }  // namespace dart