Precompilation: Don't look at embedder allocated pages when finalizing the VM isolate.

On precompiled Space Blast on an iTouch 6, reduces finalizing the vm isolate from 60ms to <1 ms, but loading the isolate snapshot doesn't happen any sooner.

R=fschneider@google.com

Review URL: https://codereview.chromium.org/1834333002 .

runtime/vm/heap.cc

@@ -260,6 +260,12 @@ void Heap::IterateOldObjects(ObjectVisitor* visitor) const {
 }
 
 
+void Heap::IterateOldObjectsNoEmbedderPages(ObjectVisitor* visitor) const {
+  HeapIterationScope heap_iteration_scope;
+  old_space_.VisitObjectsNoEmbedderPages(visitor);
+}
+
+
 void Heap::VisitObjectPointers(ObjectPointerVisitor* visitor) const {
   new_space_.VisitObjectPointers(visitor);
   old_space_.VisitObjectPointers(visitor);
@@ -511,10 +517,10 @@ bool Heap::GrowthControlState() {
 }
 
 
-void Heap::WriteProtect(bool read_only, bool include_code_pages) {
+void Heap::WriteProtect(bool read_only) {
   read_only_ = read_only;
   new_space_.WriteProtect(read_only);
-  old_space_.WriteProtect(read_only, include_code_pages);
+  old_space_.WriteProtect(read_only);
 }
 
 
@@ -840,16 +846,15 @@ NoHeapGrowthControlScope::~NoHeapGrowthControlScope() {
 }
 
 
-WritableVMIsolateScope::WritableVMIsolateScope(Thread* thread,
-                                               bool include_code_pages)
-    : StackResource(thread), include_code_pages_(include_code_pages) {
-  Dart::vm_isolate()->heap()->WriteProtect(false, include_code_pages_);
+WritableVMIsolateScope::WritableVMIsolateScope(Thread* thread)
+    : StackResource(thread) {
+  Dart::vm_isolate()->heap()->WriteProtect(false);
 }
 
 
 WritableVMIsolateScope::~WritableVMIsolateScope() {
   ASSERT(Dart::vm_isolate()->heap()->UsedInWords(Heap::kNew) == 0);
-  Dart::vm_isolate()->heap()->WriteProtect(true, include_code_pages_);
+  Dart::vm_isolate()->heap()->WriteProtect(true);
 }
 
 }  // namespace dart

runtime/vm/heap.h

@@ -102,6 +102,7 @@ class Heap {
 
   void IterateObjects(ObjectVisitor* visitor) const;
   void IterateOldObjects(ObjectVisitor* visitor) const;
+  void IterateOldObjectsNoEmbedderPages(ObjectVisitor* visitor) const;
   void IterateObjectPointers(ObjectVisitor* visitor) const;
 
   // Find an object by visiting all pointers in the specified heap space,
@@ -138,7 +139,7 @@ class Heap {
 
   // Protect access to the heap. Note: Code pages are made
   // executable/non-executable when 'read_only' is true/false, respectively.
-  void WriteProtect(bool read_only, bool include_code_pages);
+  void WriteProtect(bool read_only);
   void WriteProtectCode(bool read_only) {
     old_space_.WriteProtectCode(read_only);
   }
@@ -391,11 +392,8 @@ class NoHeapGrowthControlScope : public StackResource {
 // Note: During this scope, the code pages are non-executable.
 class WritableVMIsolateScope : StackResource {
  public:
-  explicit WritableVMIsolateScope(Thread* thread, bool include_code_pages);
+  explicit WritableVMIsolateScope(Thread* thread);
   ~WritableVMIsolateScope();
-
- private:
-  bool include_code_pages_;
 };
 
 }  // namespace dart

runtime/vm/heap_test.cc

@@ -283,9 +283,9 @@ TEST_CASE(IterateReadOnly) {
   const String& obj = String::Handle(String::New("x", Heap::kOld));
   Heap* heap = Thread::Current()->isolate()->heap();
   EXPECT(heap->Contains(RawObject::ToAddr(obj.raw())));
-  heap->WriteProtect(true, true /* include_code_pages */);
+  heap->WriteProtect(true);
   EXPECT(heap->Contains(RawObject::ToAddr(obj.raw())));
-  heap->WriteProtect(false, true /* include_code_pages */);
+  heap->WriteProtect(false);
   EXPECT(heap->Contains(RawObject::ToAddr(obj.raw())));
 }
 

runtime/vm/object.cc

@@ -912,18 +912,10 @@ class PremarkingVisitor : public ObjectVisitor {
 
   void VisitObject(RawObject* obj) {
     // Free list elements should never be marked.
+    ASSERT(!obj->IsMarked());
     if (!obj->IsFreeListElement()) {
       ASSERT(obj->IsVMHeapObject());
-      if (obj->IsMarked()) {
-        // Precompiled objects are loaded pre-marked.
-        ASSERT(Dart::IsRunningPrecompiledCode());
-        ASSERT(obj->IsInstructions() ||
-               obj->IsPcDescriptors() ||
-               obj->IsStackmap() ||
-               obj->IsOneByteString());
-      } else {
-        obj->SetMarkBitUnsynchronized();
-      }
+      obj->SetMarkBitUnsynchronized();
     }
   }
 };
@@ -994,11 +986,10 @@ void Object::FinalizeVMIsolate(Isolate* isolate) {
 
   {
     ASSERT(isolate == Dart::vm_isolate());
-    bool include_code_pages = !Dart::IsRunningPrecompiledCode();
-    WritableVMIsolateScope scope(Thread::Current(), include_code_pages);
+    WritableVMIsolateScope scope(Thread::Current());
     PremarkingVisitor premarker;
     ASSERT(isolate->heap()->UsedInWords(Heap::kNew) == 0);
-    isolate->heap()->IterateOldObjects(&premarker);
+    isolate->heap()->IterateOldObjectsNoEmbedderPages(&premarker);
     // Make the VM isolate read-only again after setting all objects as marked.
   }
 }

runtime/vm/pages.cc

@@ -611,6 +611,15 @@ void PageSpace::VisitObjects(ObjectVisitor* visitor) const {
 }
 
 
+void PageSpace::VisitObjectsNoEmbedderPages(ObjectVisitor* visitor) const {
+  for (ExclusivePageIterator it(this); !it.Done(); it.Advance()) {
+    if (!it.page()->embedder_allocated()) {
+      it.page()->VisitObjects(visitor);
+    }
+  }
+}
+
+
 void PageSpace::VisitObjectPointers(ObjectPointerVisitor* visitor) const {
   for (ExclusivePageIterator it(this); !it.Done(); it.Advance()) {
     it.page()->VisitObjectPointers(visitor);
@@ -652,15 +661,13 @@ RawObject* PageSpace::FindObject(FindObjectVisitor* visitor,
 }
 
 
-void PageSpace::WriteProtect(bool read_only, bool include_code_pages) {
+void PageSpace::WriteProtect(bool read_only) {
   if (read_only) {
     // Avoid MakeIterable trying to write to the heap.
     AbandonBumpAllocation();
   }
   for (ExclusivePageIterator it(this); !it.Done(); it.Advance()) {
-    HeapPage::PageType page_type = it.page()->type();
-    if ((page_type != HeapPage::kReadOnlyData) &&
-        ((page_type != HeapPage::kExecutable) || include_code_pages)) {
+    if (!it.page()->embedder_allocated()) {
       it.page()->WriteProtect(read_only);
     }
   }

runtime/vm/pages.h

@@ -52,6 +52,8 @@ class HeapPage {
     return type_;
   }
 
+  bool embedder_allocated() const { return memory_->embedder_allocated(); }
+
   void VisitObjects(ObjectVisitor* visitor) const;
   void VisitObjectPointers(ObjectPointerVisitor* visitor) const;
 
@@ -254,6 +256,7 @@ class PageSpace {
   }
 
   void VisitObjects(ObjectVisitor* visitor) const;
+  void VisitObjectsNoEmbedderPages(ObjectVisitor* visitor) const;
   void VisitObjectPointers(ObjectPointerVisitor* visitor) const;
 
   RawObject* FindObject(FindObjectVisitor* visitor,
@@ -292,7 +295,7 @@ class PageSpace {
 
   // Note: Code pages are made executable/non-executable when 'read_only' is
   // true/false, respectively.
-  void WriteProtect(bool read_only, bool include_code_pages);
+  void WriteProtect(bool read_only);
   void WriteProtectCode(bool read_only);
 
   void AddGCTime(int64_t micros) {