More precompiled snapshotting.

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 180 matching lines @@
       field_(Field::Handle(zone_)),
       str_(String::Handle(zone_)),
       library_(Library::Handle(zone_)),
       type_(AbstractType::Handle(zone_)),
       type_arguments_(TypeArguments::Handle(zone_)),
       tokens_(Array::Handle(zone_)),
       stream_(TokenStream::Handle(zone_)),
       data_(ExternalTypedData::Handle(zone_)),
       typed_data_(TypedData::Handle(zone_)),
       code_(Code::Handle(zone_)),
+      function_(Function::Handle(zone_)),
+      megamorphic_cache_(MegamorphicCache::Handle(zone_)),
       error_(UnhandledException::Handle(zone_)),
       max_vm_isolate_object_id_(
           (kind == Snapshot::kFull) ?
               Object::vm_isolate_snapshot_object_table().Length() : 0),
       backward_references_(backward_refs),
       instructions_reader_(NULL) {
   if (instructions_buffer != NULL) {
     instructions_reader_ = new InstructionsReader(instructions_buffer);
   }
 }
@@ skipping 446 matching lines @@
   // size for the full snapshot being read.
   {
     NoSafepointScope no_safepoint;
     HeapLocker hl(isolate, old_space());
 
     // Read in all the objects stored in the object store.
     intptr_t num_flds = (object_store->to() - object_store->from());
     for (intptr_t i = 0; i <= num_flds; i++) {
       *(object_store->from() + i) = ReadObjectImpl(kAsInlinedObject);
     }
+    if (snapshot_code_) {
+      isolate->megamorphic_cache_table()->ReadFrom(this);
+    }
     for (intptr_t i = 0; i < backward_references_->length(); i++) {
       if (!(*backward_references_)[i].is_deserialized()) {
         ReadObjectImpl(kAsInlinedObject);
         (*backward_references_)[i].set_state(kIsDeserialized);
       }
     }
 
     // Validate the class table.
 #if defined(DEBUG)
     isolate->ValidateClassTable();
@@ skipping 857 matching lines @@
         // TODO(rmacnak):
         // ArgumentsDescriptor::InitOnceFromSnapshot(i, *(ArrayHandle()));
       }
 
       ObjectPool::CheckedHandle(ReadObject());  // empty pool
       PcDescriptors::CheckedHandle(ReadObject());  // empty pc desc
       LocalVarDescriptors::CheckedHandle(ReadObject());  // empty var desc
       ExceptionHandlers::CheckedHandle(ReadObject());  // empty exc handlers
 
 #define READ_STUB(name)                                                       \
-      *(CodeHandle()) ^= ReadObject();
-      // TODO(rmacnak):
-      // StubCode::name##_entry()->InitOnceFromSnapshot(CodeHandle())
+      *(CodeHandle()) ^= ReadObject();                                        \
+      StubCode::name##_entry_ = new StubEntry(*CodeHandle());

[siva, 2015/09/14 20:32:59]

Instead of exposing the stub code macro order here it might be better to have a
StubCode::InitOnceFromSnapshot() function which will suck in the instructions
for the various stubs and then create code objects and finalize the stubs.

This would also mean that we could continue to restrict HandleVmIsolateObjects
to just the specific ones we have instead of opening it up for all generic
objects.

(Maybe we can do this cleanup in another CL).

[rmacnak, 2015/09/15 17:56:42]

Pushed to stub_code.cc and added TODO.

       VM_STUB_CODE_LIST(READ_STUB);
 #undef READ_STUB
     }
 
     // Validate the class table.
 #if defined(DEBUG)
     isolate->ValidateClassTable();
 #endif
 
     return ApiError::null();
   }
 }
 
 
 IsolateSnapshotReader::IsolateSnapshotReader(const uint8_t* buffer,
                                              intptr_t size,
                                              const uint8_t* instructions_buffer,
                                              Thread* thread)
     : SnapshotReader(buffer,
                      size,
                      instructions_buffer,
                      Snapshot::kFull,
                      new ZoneGrowableArray<BackRefNode>(
                          kNumInitialReferencesInFullSnapshot),
                      thread) {
+  Isolate::Current()->set_compilation_allowed(instructions_buffer_ == NULL);
 }
 
 
 IsolateSnapshotReader::~IsolateSnapshotReader() {
   ResetBackwardReferenceTable();
 }
 
 
 ScriptSnapshotReader::ScriptSnapshotReader(const uint8_t* buffer,
                                            intptr_t size,
@@ skipping 407 matching lines @@
     // Write out the version string.
     writer.WriteVersion();
 
     // Write out the full snapshot.
 
     // Write out all the objects in the object store of the isolate which
     // is the root set for all dart allocated objects at this point.
     SnapshotWriterVisitor visitor(&writer, false);
     object_store->VisitObjectPointers(&visitor);
 
+    if (snapshot_code_) {
+      isolate_->megamorphic_cache_table()->WriteTo(&writer);
+    }

[siva, 2015/09/14 20:32:59]

Why do you order this in between the object_store objects and it's forward
references?
Maybe this is moot once you make the megamorphic cache table into a regular dart
object and stick it into the object store.

[rmacnak, 2015/09/15 17:56:42]

Dropped.

+
     // Write out all forwarded objects.
     writer.WriteForwardedObjects();
 
     writer.FillHeader(writer.kind());
     writer.UnmarkAll();
 
     isolate_snapshot_size_ = writer.BytesWritten();
   } else {
     writer.ThrowException(writer.exception_type(), writer.exception_msg());
   }
@@ skipping 775 matching lines @@
     NoSafepointScope no_safepoint;
     WriteObject(obj.raw());
     UnmarkAll();
   } else {
     ThrowException(exception_type(), exception_msg());
   }
 }
 
 
 }  // namespace dart