Move bootstrap scripts and token streams to the VM isolate so that they become read only objects. T…

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 1166 matching lines @@
 
   // The version string matches. Read the rest of the snapshot.
 
   {
     NoSafepointScope no_safepoint;
     HeapLocker hl(isolate, old_space());
 
     // Read in the symbol table.
     object_store->symbol_table_ = reinterpret_cast<RawArray*>(ReadObject());
 
+    Symbols::InitOnceFromSnapshot(isolate);
+
+    // Read in all the script objects and the accompanying token streams
+    // for bootstrap libraries so that they are in the VM isolate's read
+    // only memory.
+    *(ArrayHandle()) ^= ReadObject();
+
     // Validate the class table.
 #if defined(DEBUG)
     isolate->ValidateClassTable();
 #endif
 
     return ApiError::null();
   }
 }
 
 
@@ skipping 262 matching lines @@
       isolate_snapshot_buffer_(isolate_snapshot_buffer),
       alloc_(alloc),
       vm_isolate_snapshot_size_(0),
       isolate_snapshot_size_(0),
       forward_list_(SnapshotWriter::FirstObjectId()) {
   ASSERT(isolate_snapshot_buffer_ != NULL);
   ASSERT(alloc_ != NULL);
 }
 
 
+// An object visitor which will iterate over all the script 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 script
+// objects and their accompanying token streams.
+class ScriptVisitor : public ObjectVisitor {
+ public:
+  explicit ScriptVisitor(Isolate* isolate) :
+      ObjectVisitor(isolate),
+      objHandle_(Object::Handle(isolate)),
+      count_(0),
+      scripts_(NULL) {}
+
+  ScriptVisitor(Isolate* isolate, const Array* scripts) :
+      ObjectVisitor(isolate),
+      objHandle_(Object::Handle(isolate)),
+      count_(0),
+      scripts_(scripts) {}
+
+  void VisitObject(RawObject* obj) {
+    if (obj->IsScript()) {
+      if (scripts_ != NULL) {
+        objHandle_ = obj;
+        scripts_->SetAt(count_, objHandle_);
+      }
+      count_ += 1;
+    }
+  }
+
+  intptr_t count() const { return count_; }
+
+ private:
+  Object& objHandle_;
+  intptr_t count_;
+  const Array* scripts_;
+};
+
+
 void FullSnapshotWriter::WriteVmIsolateSnapshot() {
   ASSERT(vm_isolate_snapshot_buffer_ != NULL);
   SnapshotWriter writer(Snapshot::kFull,
                         vm_isolate_snapshot_buffer_,
                         alloc_,
                         kInitialSize,
                         &forward_list_,
                         true);  // Can send any kind of object.
   Isolate* isolate = writer.isolate();
   ASSERT(isolate != NULL);
   ObjectStore* object_store = isolate->object_store();
   ASSERT(object_store != NULL);
   ASSERT(ClassFinalizer::AllClassesFinalized());
 
   // Ensure the class table is valid.
 #if defined(DEBUG)
   isolate->ValidateClassTable();
 #endif
 
-  // Write full snapshot for a regular isolate.
+  // Collect all the script objects and their accompanying 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 script objects, allocate an array
+  // and then fill it up with the script objects.
+  ScriptVisitor scripts_counter(isolate);
+  isolate->heap()->old_space()->VisitObjects(&scripts_counter);
+  intptr_t count = scripts_counter.count();
+  const Array& scripts = Array::Handle(isolate, Array::New(count, Heap::kOld));
+  ScriptVisitor script_visitor(isolate, &scripts);
+  isolate->heap()->old_space()->VisitObjects(&script_visitor);
+
+  // Write full snapshot for the VM isolate.
   // Setup for long jump in case there is an exception while writing
   // the snapshot.
   LongJumpScope jump;
   if (setjmp(*jump.Set()) == 0) {
     // Reserve space in the output buffer for a snapshot header.
     writer.ReserveHeader();
 
     // Write out the version string.
     writer.WriteVersion();
 
-    // Write out the symbol table.
+    /*
+     * Now Write out the following
+     * - the symbol table
+     * - all the scripts and token streams for these scripts
+     *
+     **/
     {
       NoSafepointScope no_safepoint;
 
       // Write out the symbol table and reset the symbol table for the
       // regular isolate so that we do not write these symbols into the
       // snapshot of a regular dart isolate.
       writer.WriteObject(object_store->symbol_table());
 
+      // Write out all the script objects and the accompanying token streams
+      // for the bootstrap libraries so that they are in the VM isolate
+      // read only memory.
+      writer.WriteObject(scripts.raw());
+
+      // Write out all forwarded objects.
+      writer.WriteForwardedObjects();
+
       writer.FillHeader(writer.kind());
     }
     vm_isolate_snapshot_size_ = writer.BytesWritten();
     // Reset the symbol table for the regular isolate so that we do not
     // write these symbols into the snapshot of a regular dart isolate.
     Symbols::SetupSymbolTable(isolate);
   } else {
     writer.ThrowException(writer.exception_type(), writer.exception_msg());
   }
 }
@@ skipping 705 matching lines @@
     NoSafepointScope no_safepoint;
     WriteObject(obj.raw());
     UnmarkAll();
   } else {
     ThrowException(exception_type(), exception_msg());
   }
 }
 
 
 }  // namespace dart