Move symbol table from per isolate snapshot to vm isolate snapshot, this reduces the per isolate in…

runtime/vm/dart.cc

 // Copyright (c) 2013, 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/dart.h"
 
 #include "vm/code_observers.h"
 #include "vm/cpu.h"
 #include "vm/dart_api_state.h"
 #include "vm/dart_entry.h"
@@ skipping 113 matching lines @@
                0,  // New gen size 0; VM isolate should only allocate in old.
                FLAG_old_gen_heap_size * MBInWords,
                FLAG_external_max_size * MBInWords);
     ObjectStore::Init(vm_isolate_);
     TargetCPUFeatures::InitOnce();
     Object::InitOnce(vm_isolate_);
     ArgumentsDescriptor::InitOnce();
     StubCode::InitOnce();
     // Now that the needed stub has been generated, set the stack limit.
     vm_isolate_->InitializeStackLimit();
-    Symbols::InitOnce(vm_isolate_);
+    if (vm_isolate_snapshot != NULL) {
+      const Snapshot* snapshot = Snapshot::SetupFromBuffer(vm_isolate_snapshot);
+      if (snapshot == NULL) {
+        return "Invalid vm isolate snapshot seen.";
+      }
+      ASSERT(snapshot->kind() == Snapshot::kFull);
+      VmIsolateSnapshotReader reader(snapshot->content(),
+                                     snapshot->length(),
+                                     zone.GetZone());
+      const Error& error = Error::Handle(reader.ReadVmIsolateSnapshot());
+      if (!error.IsNull()) {
+        return error.ToCString();
+      }
+      if (FLAG_trace_isolates) {
+        OS::Print("Size of vm isolate snapshot = %" Pd "\n",
+                  snapshot->length());
+        vm_isolate_->heap()->PrintSizes();
+        vm_isolate_->megamorphic_cache_table()->PrintSizes();
+        intptr_t size;
+        intptr_t capacity;
+        Symbols::GetStats(vm_isolate_, &size, &capacity);
+        OS::Print("VM Isolate: Number of symbols : %" Pd "\n", size);
+        OS::Print("VM Isolate: Symbol table capacity : %" Pd "\n", capacity);
+      }
+      Symbols::InitOnceFromSnapshot(vm_isolate_);
+    } else {
+      Symbols::InitOnce(vm_isolate_);
+    }
     Scanner::InitOnce();
 #if defined(TARGET_ARCH_IA32) || defined(TARGET_ARCH_X64)
     // Dart VM requires at least SSE2.
     if (!TargetCPUFeatures::sse2_supported()) {
       return "SSE2 is required.";
     }
 #endif
-    if (vm_isolate_snapshot != NULL) {
-      // Initializing the VM isolate from a snapshot is not implemented yet.
-      USE(vm_isolate_snapshot);
-    }
     Object::FinalizeVMIsolate(vm_isolate_);
+#if defined(DEBUG)
+    vm_isolate_->heap()->Verify(kRequireMarked);
+#endif
   }
   // There is a planned and known asymmetry here: We enter one scope for the VM
   // isolate so that we can allocate the "persistent" scoped handles for the
   // predefined API values (such as Dart_True, Dart_False and Dart_Null).
   Dart_EnterScope();
   Api::InitHandles();
 
   Thread::ExitIsolate();  // Unregister the VM isolate from this thread.
   Isolate::SetCreateCallback(create);
   Isolate::SetInterruptCallback(interrupt);
@@ skipping 77 matching lines @@
     const Snapshot* snapshot = Snapshot::SetupFromBuffer(snapshot_buffer);
     if (snapshot == NULL) {
       const String& message = String::Handle(
           String::New("Invalid snapshot."));
       return ApiError::New(message);
     }
     ASSERT(snapshot->kind() == Snapshot::kFull);
     if (FLAG_trace_isolates) {
       OS::Print("Size of isolate snapshot = %" Pd "\n", snapshot->length());
     }
-    SnapshotReader reader(snapshot->content(), snapshot->length(),
-                          Snapshot::kFull, isolate, zone.GetZone());
+    IsolateSnapshotReader reader(snapshot->content(),
+                                 snapshot->length(),
+                                 isolate,
+                                 zone.GetZone());
     const Error& error = Error::Handle(reader.ReadFullSnapshot());
     if (!error.IsNull()) {
       return error.raw();
     }
     if (FLAG_trace_isolates) {
       isolate->heap()->PrintSizes();
       isolate->megamorphic_cache_table()->PrintSizes();
     }
+  } else {
+    // Populate the isolate's symbol table with all symbols from the
+    // VM isolate. We do this so that when we generate a full snapshot
+    // for the isolate we have a unified symbol table that we can then
+    // read into the VM isolate.
+    Symbols::AddPredefinedSymbolsToIsolate();
   }
 
   Object::VerifyBuiltinVtables();
 
   StubCode::Init(isolate);
   if (snapshot_buffer == NULL) {
     if (!isolate->object_store()->PreallocateObjects()) {
       return isolate->object_store()->sticky_error();
     }
   }
@@ skipping 50 matching lines @@
   return predefined_handles_->handles_.AllocateScopedHandle();
 }
 
 
 bool Dart::IsReadOnlyHandle(uword address) {
   ASSERT(predefined_handles_ != NULL);
   return predefined_handles_->handles_.IsValidScopedHandle(address);
 }
 
 }  // namespace dart