When deduplicating program metadata, try to use objects from the VM isolate.

runtime/vm/clustered_snapshot.cc

 // Copyright (c) 2016, 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/clustered_snapshot.h"
 
 #include "platform/assert.h"
 #include "vm/bootstrap.h"
 #include "vm/class_finalizer.h"
 #include "vm/dart.h"
@@ skipping 4768 matching lines @@
   AddBaseObject(table->At(kVoidCid));
 
   if (!Snapshot::IncludesCode(kind_)) {
     for (intptr_t i = 0; i < StubCode::NumEntries(); i++) {
       AddBaseObject(StubCode::EntryAt(i)->code());
     }
   }
 }
 
 intptr_t Serializer::WriteVMSnapshot(const Array& symbols,
-                                     const Array& scripts) {
+                                     ZoneGrowableArray<Object*>* seed_objects,
+                                     ZoneGrowableArray<Code*>* seed_code) {
   NoSafepointScope no_safepoint;
 
   AddVMIsolateBaseObjects();
 
   // Push roots.
   Push(symbols.raw());
-  Push(scripts.raw());
   if (Snapshot::IncludesCode(kind_)) {
     for (intptr_t i = 0; i < StubCode::NumEntries(); i++) {
       Push(StubCode::EntryAt(i)->code());
     }
   }
+  if (seed_objects != NULL) {
+    for (intptr_t i = 0; i < seed_objects->length(); i++) {
+      Push((*seed_objects)[i]->raw());
+    }
+  }
+  if (seed_code != NULL) {
+    for (intptr_t i = 0; i < seed_code->length(); i++) {
+      Code* code = (*seed_code)[i];
+      GetTextOffset(code->instructions(), code->raw());
+    }
+  }
 
   Serialize();
 
   // Write roots.
   WriteRef(symbols.raw());
-  WriteRef(scripts.raw());
   if (Snapshot::IncludesCode(kind_)) {
     for (intptr_t i = 0; i < StubCode::NumEntries(); i++) {
       WriteRef(StubCode::EntryAt(i)->code());
     }
   }
 
 #if defined(DEBUG)
   Write<int32_t>(kSectionMarker);
 #endif
 
   // Note we are not clearing the object id table. The full ref table
   // of the vm isolate snapshot serves as the base objects for the
   // regular isolate snapshot.
 
   // Return the number of objects, -1 accounts for unused ref 0.
   return next_ref_index_ - 1;
 }
 
+// Collects Instructions from the VM isolate and adds them to object id table
+// with offsets that will refer to the VM snapshot, causing them to be shared
+// across isolates.
+class SeedInstructionsVisitor : public ObjectVisitor {
+ public:
+  SeedInstructionsVisitor(uword text_base, Heap* heap)
+      : text_base_(text_base), heap_(heap) {}
+
+  void VisitObject(RawObject* obj) {
+    if (obj->IsInstructions()) {
+      uword addr = reinterpret_cast<uword>(obj) - kHeapObjectTag;
+      int32_t offset = addr - text_base_;
+      heap_->SetObjectId(obj, -offset);
+    }
+  }
+
+ private:
+  uword text_base_;
+  Heap* heap_;
+};
+
 void Serializer::WriteIsolateSnapshot(intptr_t num_base_objects,
                                       ObjectStore* object_store) {
   NoSafepointScope no_safepoint;
 
   if (num_base_objects == 0) {
-    // Units tests not writing a new vm isolate.
+    // Not writing a new vm isolate: use the one this VM was loaded from.
     const Array& base_objects = Object::vm_isolate_snapshot_object_table();
     for (intptr_t i = 1; i < base_objects.Length(); i++) {
       AddBaseObject(base_objects.At(i));
     }
+    const uint8_t* text_base = Dart::vm_snapshot_instructions();
+    if (text_base != NULL) {
+      SeedInstructionsVisitor visitor(reinterpret_cast<uword>(text_base),
+                                      heap_);
+      Dart::vm_isolate()->heap()->VisitObjectsImagePages(&visitor);
+    }
   } else {
     // Base objects carried over from WriteVMIsolateSnapshot.
     num_base_objects_ += num_base_objects;
     next_ref_index_ += num_base_objects;
   }
 
   // Push roots.
   RawObject** from = object_store->from();
   RawObject** to = object_store->to_snapshot(kind_);
   for (RawObject** p = from; p <= to; p++) {
@@ skipping 342 matching lines @@
     NoSafepointScope no_safepoint;
     HeapLocker hl(thread(), heap_->old_space());
 
     AddVMIsolateBaseObjects();
 
     Deserialize();
 
     // Read roots.
     symbol_table ^= ReadRef();
     isolate()->object_store()->set_symbol_table(symbol_table);
-    ReadRef();  // Script list.
     if (Snapshot::IncludesCode(kind_)) {
       Code& code = Code::Handle(zone_);
       for (intptr_t i = 0; i < StubCode::NumEntries(); i++) {
         code ^= ReadRef();
         StubCode::EntryAtPut(i, new StubEntry(code));
       }
     }
 
 #if defined(DEBUG)
     int32_t section_marker = Read<int32_t>();
@@ skipping 60 matching lines @@
         thread(), Timeline::GetIsolateStream(), "PostLoad"));
     for (intptr_t i = 0; i < num_clusters_; i++) {
       clusters_[i]->PostLoad(refs, kind_, zone_);
     }
   }
 
   // Setup native resolver for bootstrap impl.
   Bootstrap::SetupNativeResolver();
 }
 
-// An object visitor which will iterate over all the token stream objects in the
-// heap and either count them or collect them into an array. This is used during
-// full snapshot generation of the VM isolate to write out all token streams so
-// they will be shared across all isolates.
-class SnapshotTokenStreamVisitor : public ObjectVisitor {
+// An object visitor which iterates the heap looking for objects to write into
+// the VM isolate's snapshot, causing them to be shared across isolates.
+class SeedVMIsolateVisitor : public ObjectVisitor {
  public:
-  explicit SnapshotTokenStreamVisitor(Thread* thread)
-      : objHandle_(Object::Handle(thread->zone())),
-        count_(0),
-        token_streams_(NULL) {}
-
-  SnapshotTokenStreamVisitor(Thread* thread, const Array* token_streams)
-      : objHandle_(Object::Handle(thread->zone())),
-        count_(0),
-        token_streams_(token_streams) {}
+  SeedVMIsolateVisitor(Zone* zone, bool include_code)
+      : zone_(zone),
+        include_code_(include_code),
+        objects_(new (zone) ZoneGrowableArray<Object*>(4 * KB)),
+        code_(new (zone) ZoneGrowableArray<Code*>(4 * KB)) {}
 
   void VisitObject(RawObject* obj) {
     if (obj->IsTokenStream()) {
-      if (token_streams_ != NULL) {
-        objHandle_ = obj;
-        token_streams_->SetAt(count_, objHandle_);
+      objects_->Add(&Object::Handle(zone_, obj));
+    } else if (include_code_) {
+      if (obj->IsStackMap() || obj->IsPcDescriptors() ||
+          obj->IsCodeSourceMap()) {
+        objects_->Add(&Object::Handle(zone_, obj));
+      } else if (obj->IsCode()) {
+        code_->Add(&Code::Handle(zone_, Code::RawCast(obj)));
       }
-      count_ += 1;
     }
   }
 
-  intptr_t count() const { return count_; }
+  ZoneGrowableArray<Object*>* objects() { return objects_; }
+  ZoneGrowableArray<Code*>* code() { return code_; }
 
  private:
-  Object& objHandle_;
-  intptr_t count_;
-  const Array* token_streams_;
+  Zone* zone_;
+  bool include_code_;
+  ZoneGrowableArray<Object*>* objects_;
+  ZoneGrowableArray<Code*>* code_;
 };
 
 FullSnapshotWriter::FullSnapshotWriter(Snapshot::Kind kind,
                                        uint8_t** vm_snapshot_data_buffer,
                                        uint8_t** isolate_snapshot_data_buffer,
                                        ReAlloc alloc,
                                        ImageWriter* vm_image_writer,
                                        ImageWriter* isolate_image_writer)
     : thread_(Thread::Current()),
       kind_(kind),
       vm_snapshot_data_buffer_(vm_snapshot_data_buffer),
       isolate_snapshot_data_buffer_(isolate_snapshot_data_buffer),
       alloc_(alloc),
       vm_isolate_snapshot_size_(0),
       isolate_snapshot_size_(0),
       vm_image_writer_(vm_image_writer),
       isolate_image_writer_(isolate_image_writer),
-      token_streams_(Array::Handle(zone())),
+      seed_objects_(NULL),
+      seed_code_(NULL),
       saved_symbol_table_(Array::Handle(zone())),
       new_vm_symbol_table_(Array::Handle(zone())),
       clustered_vm_size_(0),
       clustered_isolate_size_(0),
       mapped_data_size_(0),
       mapped_instructions_size_(0) {
   ASSERT(alloc_ != NULL);
   ASSERT(isolate() != NULL);
   ASSERT(ClassFinalizer::AllClassesFinalized());
   ASSERT(isolate() != NULL);
@@ skipping 10 matching lines @@
 
   // TODO(rmacnak): The special case for AOT causes us to always generate the
   // same VM isolate snapshot for every app. AOT snapshots should be cleaned up
   // so the VM isolate snapshot is generated separately and each app is
   // generated from a VM that has loaded this snapshots, much like app-jit
   // snapshots.
   if ((vm_snapshot_data_buffer != NULL) && (kind != Snapshot::kFullAOT)) {
     NOT_IN_PRODUCT(TimelineDurationScope tds(
         thread(), Timeline::GetIsolateStream(), "PrepareNewVMIsolate"));
 
-    // Collect all the token stream objects into an array so that we can write
-    // it out as part of the VM isolate snapshot. We first count the number of
-    // token streams, allocate an array and then fill it up with the token
-    // streams.
-    {
-      HeapIterationScope iteration(thread());
-      SnapshotTokenStreamVisitor token_streams_counter(thread());
-      iteration.IterateObjects(&token_streams_counter);
-      iteration.IterateVMIsolateObjects(&token_streams_counter);
-      intptr_t count = token_streams_counter.count();
-      token_streams_ = Array::New(count, Heap::kOld);
-      SnapshotTokenStreamVisitor script_visitor(thread(), &token_streams_);
-      iteration.IterateObjects(&script_visitor);
-      iteration.IterateVMIsolateObjects(&script_visitor);
-      ASSERT(script_visitor.count() == count);
-    }
+    HeapIterationScope iteration(thread());
+    SeedVMIsolateVisitor visitor(thread()->zone(),
+                                 Snapshot::IncludesCode(kind));
+    iteration.IterateObjects(&visitor);
+    iteration.IterateVMIsolateObjects(&visitor);
+    seed_objects_ = visitor.objects();
+    seed_code_ = visitor.code();
 
     // Tuck away the current symbol table.
     saved_symbol_table_ = object_store->symbol_table();
 
     // Create a unified symbol table that will be written as the vm isolate's
     // symbol table.
     new_vm_symbol_table_ = Symbols::UnifiedSymbolTable();
 
     // Create an empty symbol table that will be written as the isolate's symbol
     // table.
     Symbols::SetupSymbolTable(isolate());
   } else {
     // Reuse the current vm isolate.
     saved_symbol_table_ = object_store->symbol_table();
     new_vm_symbol_table_ = Dart::vm_isolate()->object_store()->symbol_table();
   }
 }
 
 FullSnapshotWriter::~FullSnapshotWriter() {
   // We may run Dart code afterwards, restore the symbol table if needed.
   if (!saved_symbol_table_.IsNull()) {
     isolate()->object_store()->set_symbol_table(saved_symbol_table_);
     saved_symbol_table_ = Array::null();
   }
   new_vm_symbol_table_ = Array::null();
-  token_streams_ = Array::null();
 }
 
 intptr_t FullSnapshotWriter::WriteVMSnapshot() {
   NOT_IN_PRODUCT(TimelineDurationScope tds(
       thread(), Timeline::GetIsolateStream(), "WriteVMSnapshot"));
 
   ASSERT(vm_snapshot_data_buffer_ != NULL);
   Serializer serializer(thread(), kind_, vm_snapshot_data_buffer_, alloc_,
                         kInitialSize, vm_image_writer_);
 
   serializer.ReserveHeader();
   serializer.WriteVersionAndFeatures();
   // VM snapshot roots are:
   // - the symbol table
   // - all the token streams
   // - the stub code (precompiled snapshots only)
-  intptr_t num_objects =
-      serializer.WriteVMSnapshot(new_vm_symbol_table_, token_streams_);
+  intptr_t num_objects = serializer.WriteVMSnapshot(new_vm_symbol_table_,
+                                                    seed_objects_, seed_code_);
   serializer.FillHeader(serializer.kind());
   clustered_vm_size_ = serializer.bytes_written();
 
   if (Snapshot::IncludesCode(kind_)) {
     vm_image_writer_->Write(serializer.stream(), true);
     mapped_data_size_ += vm_image_writer_->data_size();
     mapped_instructions_size_ += vm_image_writer_->text_size();
     vm_image_writer_->ResetOffsets();
   }
 
@@ skipping 84 matching lines @@
     return error;
   }
 
   if (Snapshot::IncludesCode(kind_)) {
     ASSERT(instructions_buffer_ != NULL);
     thread_->isolate()->SetupImagePage(instructions_buffer_,
                                        /* is_executable */ true);
     ASSERT(data_buffer_ != NULL);
     thread_->isolate()->SetupImagePage(data_buffer_,
                                        /* is_executable */ false);
+    Dart::set_vm_snapshot_instructions(instructions_buffer_);
   }
 
   deserializer.ReadVMSnapshot();
 
   return ApiError::null();
 }
 
 RawApiError* FullSnapshotReader::ReadIsolateSnapshot() {
   Deserializer deserializer(thread_, kind_, buffer_, size_,
                             instructions_buffer_, data_buffer_);
@@ skipping 12 matching lines @@
     thread_->isolate()->SetupImagePage(data_buffer_,
                                        /* is_executable */ false);
   }
 
   deserializer.ReadIsolateSnapshot(thread_->isolate()->object_store());
 
   return ApiError::null();
 }
 
 }  // namespace dart