Refactor snapshots pieces to include a section for loading instructions into the heap of a regular …

runtime/vm/snapshot.cc

 // 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.
 
 #include "vm/snapshot.h"
 
 #include "platform/assert.h"
 #include "vm/bootstrap.h"
 #include "vm/class_finalizer.h"
 #include "vm/dart.h"
@@ skipping 690 matching lines @@
 
 int32_t InstructionsWriter::GetObjectOffsetFor(RawObject* raw_object) {
   intptr_t heap_size = raw_object->Size();
   intptr_t offset = next_object_offset_;
   next_object_offset_ += heap_size;
   objects_.Add(ObjectData(raw_object));
   return offset;
 }
 
 
+void InstructionsWriter::HandlifyObjects() {
+  Zone* zone = Thread::Current()->zone();
+  for (intptr_t i = 0; i < instructions_.length(); i++) {
+    InstructionsData& data = instructions_[i];
+    data.insns_ = &Instructions::Handle(zone, data.raw_insns_);
+    ASSERT(data.raw_code_ != NULL);
+    data.code_ = &Code::Handle(zone, data.raw_code_);
+  }
+  for (intptr_t i = 0; i < objects_.length(); i++) {
+    ObjectData& data = objects_[i];
+    data.obj_ = &Object::Handle(zone, data.raw_obj_);
+  }
+}
+
+
+void InstructionsWriter::WriteROData(WriteStream* stream) {
+  stream->Align(OS::kMaxPreferredCodeAlignment);
+
+  // Heap page starts here.
+
+  stream->WriteWord(next_object_offset_);  // Data length.
+  COMPILE_ASSERT(OS::kMaxPreferredCodeAlignment >= kObjectAlignment);
+  stream->Align(OS::kMaxPreferredCodeAlignment);
+
+  // Heap page objects start here.
+
+  for (intptr_t i = 0; i < objects_.length(); i++) {
+    const Object& obj = *objects_[i].obj_;
+
+    NoSafepointScope no_safepoint;
+    uword start = reinterpret_cast<uword>(obj.raw()) - kHeapObjectTag;
+    uword end = start + obj.raw()->Size();
+
+    // Write object header with the mark and VM heap bits set.
+    uword marked_tags = obj.raw()->ptr()->tags_;
+    marked_tags = RawObject::VMHeapObjectTag::update(true, marked_tags);
+    marked_tags = RawObject::MarkBit::update(true, marked_tags);
+    stream->WriteWord(marked_tags);
+    start += sizeof(uword);
+    for (uword* cursor = reinterpret_cast<uword*>(start);
+         cursor < reinterpret_cast<uword*>(end); cursor++) {
+      stream->WriteWord(*cursor);
+    }
+  }
+}
+
+
 static void EnsureIdentifier(char* label) {
   for (char c = *label; c != '\0'; c = *++label) {
     if (((c >= 'a') && (c <= 'z')) || ((c >= 'A') && (c <= 'Z')) ||
         ((c >= '0') && (c <= '9'))) {
       continue;
     }
     *label = '_';
   }
 }
 
 
-void AssemblyInstructionsWriter::Write(uint8_t* vmisolate_buffer,
-                                       intptr_t vmisolate_length,
-                                       uint8_t* isolate_buffer,
-                                       intptr_t isolate_length) {
+void AssemblyInstructionsWriter::Write(WriteStream* clustered_stream, bool vm) {
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
   NOT_IN_PRODUCT(TimelineDurationScope tds(thread, Timeline::GetIsolateStream(),
                                            "WriteInstructions"));
 
   // Handlify collected raw pointers as building the names below
   // will allocate on the Dart heap.
-  for (intptr_t i = 0; i < instructions_.length(); i++) {
-    InstructionsData& data = instructions_[i];
-    data.insns_ = &Instructions::Handle(zone, data.raw_insns_);
-    ASSERT(data.raw_code_ != NULL);
-    data.code_ = &Code::Handle(zone, data.raw_code_);
-  }
-  for (intptr_t i = 0; i < objects_.length(); i++) {
-    ObjectData& data = objects_[i];
-    data.obj_ = &Object::Handle(zone, data.raw_obj_);
-  }
+  HandlifyObjects();
 
+  // Append the direct-mapped RO data objects after the clustered snapshot.
+  WriteROData(clustered_stream);

[siva, 2017/01/20 22:53:54]

These two calls (HandlifyObjects and WriteROData) are back to back always why
not combine them into one function?

Since HandlifyObjects creates regular scoped handles there is a danger that
somebody might modify this code at some point as
{
  HANDLESCOPE(thread);
  HandlifyObjects();
  ...
  ....
}
WriteROData(...);

[rmacnak, 2017/01/21 00:50:43]

Commoned this sequence in one InstructionsWriter::Write and moved the remaining
the following parts to Assemebly|BlobsInstructionsWriter::WriteText.

+
+  const char* instructions_symbol =
+      vm ? "_kDartVmSnapshotInstructions" : "_kDartIsolateSnapshotInstructions";
   assembly_stream_.Print(".text\n");
-  assembly_stream_.Print(".globl _kInstructionsSnapshot\n");
+  assembly_stream_.Print(".globl %s\n", instructions_symbol);
   // Start snapshot at page boundary.
   ASSERT(VirtualMemory::PageSize() >= OS::kMaxPreferredCodeAlignment);
   assembly_stream_.Print(".balign %" Pd ", 0\n", VirtualMemory::PageSize());
-  assembly_stream_.Print("_kInstructionsSnapshot:\n");
+  assembly_stream_.Print("%s:\n", instructions_symbol);
 
   // This head also provides the gap to make the instructions snapshot
   // look like a HeapPage.
   intptr_t instructions_length = next_offset_;
   WriteWordLiteralText(instructions_length);
   intptr_t header_words = InstructionsSnapshot::kHeaderSize / sizeof(uword);
   for (intptr_t i = 1; i < header_words; i++) {
     WriteWordLiteralText(0);
   }
 
@@ skipping 61 matching lines @@
       ASSERT(Utils::IsAligned(beginning, sizeof(uint64_t)));
       ASSERT(Utils::IsAligned(entry, sizeof(uint64_t)));
       ASSERT(Utils::IsAligned(end, sizeof(uint64_t)));
 
       for (uword* cursor = reinterpret_cast<uword*>(entry);
            cursor < reinterpret_cast<uword*>(end); cursor++) {
         WriteWordLiteralText(*cursor);
       }
     }
   }
+
+
 #if defined(TARGET_OS_LINUX)
   assembly_stream_.Print(".section .rodata\n");
 #elif defined(TARGET_OS_MACOS)
   assembly_stream_.Print(".const\n");
 #else
   // Unsupported platform.
   UNREACHABLE();
 #endif
-  assembly_stream_.Print(".globl _kDataSnapshot\n");
-  // Start snapshot at page boundary.
-  assembly_stream_.Print(".balign %" Pd ", 0\n", VirtualMemory::PageSize());
-  assembly_stream_.Print("_kDataSnapshot:\n");
-  WriteWordLiteralData(next_object_offset_);  // Data length.
-  COMPILE_ASSERT(OS::kMaxPreferredCodeAlignment >= kObjectAlignment);
+
+  const char* data_symbol =
+      vm ? "_kDartVmSnapshotData" : "_kDartIsolateSnapshotData";
+  assembly_stream_.Print(".globl %s\n", data_symbol);
   assembly_stream_.Print(".balign %" Pd ", 0\n",
                          OS::kMaxPreferredCodeAlignment);
-
-  for (intptr_t i = 0; i < objects_.length(); i++) {
-    const Object& obj = *objects_[i].obj_;
-    assembly_stream_.Print("Precompiled_Obj_%d:\n", i);
-
-    NoSafepointScope no_safepoint;
-    uword start = reinterpret_cast<uword>(obj.raw()) - kHeapObjectTag;
-    uword end = start + obj.raw()->Size();
-
-    // Write object header with the mark and VM heap bits set.
-    uword marked_tags = obj.raw()->ptr()->tags_;
-    marked_tags = RawObject::VMHeapObjectTag::update(true, marked_tags);
-    marked_tags = RawObject::MarkBit::update(true, marked_tags);
-    WriteWordLiteralData(marked_tags);
-    start += sizeof(uword);
-    for (uword* cursor = reinterpret_cast<uword*>(start);
-         cursor < reinterpret_cast<uword*>(end); cursor++) {
-      WriteWordLiteralData(*cursor);
-    }
-  }
-
-
-  assembly_stream_.Print(".globl _kVmIsolateSnapshot\n");
-  assembly_stream_.Print(".balign %" Pd ", 0\n", VirtualMemory::PageSize());
-  assembly_stream_.Print("_kVmIsolateSnapshot:\n");
-  for (intptr_t i = 0; i < vmisolate_length; i++) {
-    assembly_stream_.Print(".byte %" Pd "\n", vmisolate_buffer[i]);
-  }
-
-  assembly_stream_.Print(".globl _kIsolateSnapshot\n");
-  assembly_stream_.Print(".balign %" Pd ", 0\n", VirtualMemory::PageSize());
-  assembly_stream_.Print("_kIsolateSnapshot:\n");
-  for (intptr_t i = 0; i < isolate_length; i++) {
-    assembly_stream_.Print(".byte %" Pd "\n", isolate_buffer[i]);
+  assembly_stream_.Print("%s:\n", data_symbol);
+  uint8_t* buffer = clustered_stream->buffer();
+  intptr_t length = clustered_stream->bytes_written();
+  for (intptr_t i = 0; i < length; i++) {
+    assembly_stream_.Print(".byte %" Pd "\n", buffer[i]);
   }
 }
 
 
-void BlobInstructionsWriter::Write(uint8_t* vmisolate_buffer,
-                                   intptr_t vmisolate_len,
-                                   uint8_t* isolate_buffer,
-                                   intptr_t isolate_length) {
-  Thread* thread = Thread::Current();
-  Zone* zone = thread->zone();
-  NOT_IN_PRODUCT(TimelineDurationScope tds(thread, Timeline::GetIsolateStream(),
-                                           "WriteInstructions"));
+void BlobInstructionsWriter::Write(WriteStream* clustered_stream, bool vm) {
+  NOT_IN_PRODUCT(TimelineDurationScope tds(
+      Thread::Current(), Timeline::GetIsolateStream(), "WriteInstructions"));
 
   // Handlify collected raw pointers as building the names below
   // will allocate on the Dart heap.
-  for (intptr_t i = 0; i < instructions_.length(); i++) {
-    InstructionsData& data = instructions_[i];
-    data.insns_ = &Instructions::Handle(zone, data.raw_insns_);
-    ASSERT(data.raw_code_ != NULL);
-    data.code_ = &Code::Handle(zone, data.raw_code_);
-  }
-  for (intptr_t i = 0; i < objects_.length(); i++) {
-    ObjectData& data = objects_[i];
-    data.obj_ = &Object::Handle(zone, data.raw_obj_);
-  }
+  HandlifyObjects();
+
+  // Append the direct-mapped RO data objects after the clustered snapshot.
+  WriteROData(clustered_stream);

[siva, 2017/01/20 22:53:54]

Ditto comment.

 
   // This head also provides the gap to make the instructions snapshot
   // look like a HeapPage.
   intptr_t instructions_length = next_offset_;
   instructions_blob_stream_.WriteWord(instructions_length);
   intptr_t header_words = InstructionsSnapshot::kHeaderSize / sizeof(uword);
   for (intptr_t i = 1; i < header_words; i++) {
     instructions_blob_stream_.WriteWord(0);
   }
 
@@ skipping 36 matching lines @@
       ASSERT(Utils::IsAligned(beginning, sizeof(uint64_t)));
       ASSERT(Utils::IsAligned(entry, sizeof(uint64_t)));
       ASSERT(Utils::IsAligned(end, sizeof(uint64_t)));
 
       for (uword* cursor = reinterpret_cast<uword*>(entry);
            cursor < reinterpret_cast<uword*>(end); cursor++) {
         instructions_blob_stream_.WriteWord(*cursor);
       }
     }
   }
-
-  rodata_blob_stream_.WriteWord(next_object_offset_);  // Data length.
-  COMPILE_ASSERT(OS::kMaxPreferredCodeAlignment >= kObjectAlignment);
-  while (!Utils::IsAligned(rodata_blob_stream_.bytes_written(),
-                           OS::kMaxPreferredCodeAlignment)) {
-    rodata_blob_stream_.WriteWord(0);
-  }
-
-  for (intptr_t i = 0; i < objects_.length(); i++) {
-    const Object& obj = *objects_[i].obj_;
-
-    NoSafepointScope no_safepoint;
-    uword start = reinterpret_cast<uword>(obj.raw()) - kHeapObjectTag;
-    uword end = start + obj.raw()->Size();
-
-    // Write object header with the mark and VM heap bits set.
-    uword marked_tags = obj.raw()->ptr()->tags_;
-    marked_tags = RawObject::VMHeapObjectTag::update(true, marked_tags);
-    marked_tags = RawObject::MarkBit::update(true, marked_tags);
-    rodata_blob_stream_.WriteWord(marked_tags);
-    start += sizeof(uword);
-    for (uword* cursor = reinterpret_cast<uword*>(start);
-         cursor < reinterpret_cast<uword*>(end); cursor++) {
-      rodata_blob_stream_.WriteWord(*cursor);
-    }
-  }
 }
 
 
-uword InstructionsReader::GetInstructionsAt(int32_t offset) {
+RawInstructions* InstructionsReader::GetInstructionsAt(int32_t offset) {
   ASSERT(Utils::IsAligned(offset, OS::PreferredCodeAlignment()));
-  return reinterpret_cast<uword>(instructions_buffer_) + offset;
+
+  RawInstructions* result = reinterpret_cast<RawInstructions*>(
+      reinterpret_cast<uword>(instructions_buffer_) + offset + kHeapObjectTag);
+  ASSERT(result->IsInstructions());
+  ASSERT(result->IsMarked());
+
+  return result;
 }
 
 
 RawObject* InstructionsReader::GetObjectAt(int32_t offset) {
   ASSERT(Utils::IsAligned(offset, kWordSize));
 
   RawObject* result = reinterpret_cast<RawObject*>(
       reinterpret_cast<uword>(data_buffer_) + offset + kHeapObjectTag);
   ASSERT(result->IsMarked());
 
@@ skipping 957 matching lines @@
     NoSafepointScope no_safepoint;
     WriteObject(obj.raw());
   } else {
     FreeBuffer();
     ThrowException(exception_type(), exception_msg());
   }
 }
 
 
 }  // namespace dart