Use clustered serialization for full snapshots.

runtime/vm/object.h

 // 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.
 
 #ifndef VM_OBJECT_H_
 #define VM_OBJECT_H_
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "platform/utils.h"
@@ skipping 486 matching lines @@
   }
   static const Type& dynamic_type() {
     ASSERT(dynamic_type_ != NULL);
     return *dynamic_type_;
   }
   static const Type& void_type() {
     ASSERT(void_type_ != NULL);
     return *void_type_;
   }
 
-  static void InitVmIsolateSnapshotObjectTable(intptr_t len);
+  static void set_vm_isolate_snapshot_object_table(const Array& table);
 
   static RawClass* class_class() { return class_class_; }
   static RawClass* dynamic_class() { return dynamic_class_; }
   static RawClass* void_class() { return void_class_; }
   static RawClass* unresolved_class_class() { return unresolved_class_class_; }
   static RawClass* type_arguments_class() { return type_arguments_class_; }
   static RawClass* patch_class_class() { return patch_class_class_; }
   static RawClass* function_class() { return function_class_; }
   static RawClass* closure_data_class() { return closure_data_class_; }
   static RawClass* redirection_data_class() { return redirection_data_class_; }
@@ skipping 310 matching lines @@
   static LanguageError* speculative_inlining_error_;
   static LanguageError* background_compilation_error_;
   static Array* vm_isolate_snapshot_object_table_;
   static Type* dynamic_type_;
   static Type* void_type_;
 
   friend void ClassTable::Register(const Class& cls);
   friend void RawObject::Validate(Isolate* isolate) const;
   friend class Closure;
   friend class SnapshotReader;
+  friend class InstanceDeserializationCluster;
   friend class OneByteString;
   friend class TwoByteString;
   friend class ExternalOneByteString;
   friend class ExternalTwoByteString;
   friend class Thread;
 
 #define REUSABLE_FRIEND_DECLARATION(name)                                      \
   friend class Reusable##name##HandleScope;
 REUSABLE_HANDLE_LIST(REUSABLE_FRIEND_DECLARATION)
 #undef REUSABLE_FRIEND_DECLARATION
@@ skipping 1362 matching lines @@
                                   bool is_static_call);
 
   static void WriteSentinel(const Array& data, intptr_t test_entry_length);
 
   // A cache of VM heap allocated preinitialized empty ic data entry arrays.
   static RawArray* cached_icdata_arrays_[kCachedICDataArrayCount];
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(ICData, Object);
   friend class Class;
   friend class SnapshotWriter;
+  friend class Serializer;
+  friend class Deserializer;
 };
 
 
 class Function : public Object {
  public:
   RawString* name() const { return raw_ptr()->name_; }
   RawString* UserVisibleName() const;  // Same as scrubbed name.
   RawString* QualifiedScrubbedName() const {
     return QualifiedName(kScrubbedName);
   }
@@ skipping 1098 matching lines @@
   void set_kind_bits(uint8_t value) const {
     StoreNonPointer(&raw_ptr()->kind_bits_, value);
   }
 
   static RawField* New();
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(Field, Object);
   friend class Class;
   friend class HeapProfiler;
   friend class RawField;
+  friend class FieldSerializationCluster;
 };
 
 
 class LiteralToken : public Object {
  public:
   Token::Kind kind() const { return raw_ptr()->kind_; }
   RawString* literal() const { return raw_ptr()->literal_; }
   RawObject* value() const { return raw_ptr()->value_; }
 
   static intptr_t InstanceSize() {
@@ skipping 504 matching lines @@
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(Library, Object);
 
   friend class Bootstrap;
   friend class Class;
   friend class Debugger;
   friend class Isolate;
   friend class DictionaryIterator;
   friend class Namespace;
   friend class Object;
+  friend class LibraryDeserializationCluster;
 };
 
 
 // A Namespace contains the names in a library dictionary, filtered by
 // the show/hide combinators.
 class Namespace : public Object {
  public:
   RawLibrary* library() const { return raw_ptr()->library_; }
   RawArray* show_names() const { return raw_ptr()->show_names_; }
   RawArray* hide_names() const { return raw_ptr()->hide_names_; }
@@ skipping 981 matching lines @@
 
   // New is a private method as RawInstruction and RawCode objects should
   // only be created using the Code::FinalizeCode method. This method creates
   // the RawInstruction and RawCode objects, sets up the pointer offsets
   // and links the two in a GC safe manner.
   static RawCode* New(intptr_t pointer_offsets_length);
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(Code, Object);
   friend class Class;
   friend class SnapshotWriter;
+  friend class FunctionSerializationCluster;
+  friend class CodeSerializationCluster;
   friend class CodePatcher;  // for set_instructions
   friend class Precompiler;  // for set_instructions
   // So that the RawFunction pointer visitor can determine whether code the
   // function points to is optimized.
   friend class RawFunction;
 };
 
 
 class Context : public Object {
  public:
@@ skipping 533 matching lines @@
   // TODO(iposva): Determine if this gets in the way of Smi.
   HEAP_OBJECT_IMPLEMENTATION(Instance, Object);
   friend class ByteBuffer;
   friend class Class;
   friend class Closure;
   friend class DeferredObject;
   friend class RegExp;
   friend class SnapshotWriter;
   friend class StubCode;
   friend class TypedDataView;
+  friend class InstanceSerializationCluster;
+  friend class InstanceDeserializationCluster;
+  friend class ClassDeserializationCluster;  // vtable
 };
 
 
 class LibraryPrefix : public Instance {
  public:
   RawString* name() const { return raw_ptr()->name_; }
   virtual RawString* DictionaryName() const { return name(); }
 
   RawArray* imports() const { return raw_ptr()->imports_; }
   intptr_t num_imports() const { return raw_ptr()->num_imports_; }
@@ skipping 1353 matching lines @@
   friend class StringSlice;  // SetHash
   template<typename CharType> friend class CharArray;  // SetHash
   friend class ConcatString;  // SetHash
   friend class OneByteString;
   friend class TwoByteString;
   friend class ExternalOneByteString;
   friend class ExternalTwoByteString;
   // So that SkippedCodeFunctions can print a debug string from a NoHandleScope.
   friend class SkippedCodeFunctions;
   friend class RawOneByteString;
+  friend class RODataSerializationCluster;  // SetHash
 };
 
 
 class OneByteString : public AllStatic {
  public:
   static uint16_t CharAt(const String& str, intptr_t index) {
     ASSERT((index >= 0) && (index < str.Length()));
     ASSERT(str.IsOneByteString());
     return raw_ptr(str)->data()[index];
   }
@@ skipping 1326 matching lines @@
 
   // Keep this in sync with Dart implementation (lib/compact_hash.dart).
   static const intptr_t kInitialIndexBits = 3;
   static const intptr_t kInitialIndexSize = 1 << (kInitialIndexBits + 1);
 
   // Allocate a map, but leave all fields set to null.
   // Used during deserialization (since map might contain itself as key/value).
   static RawLinkedHashMap* NewUninitialized(Heap::Space space = Heap::kNew);
 
   friend class Class;
+  friend class LinkedHashMapDeserializationCluster;
 };
 
 
 class Closure : public Instance {
  public:
   RawFunction* function() const { return raw_ptr()->function_; }
   void set_function(const Function& function) const {
     // TODO(regis): Only used from deferred_objects.cc. Remove once fixed.
     StorePointer(&raw_ptr()->function_, function.raw());
   }
@@ skipping 581 matching lines @@
 
 inline void TypeArguments::SetHash(intptr_t value) const {
   // This is only safe because we create a new Smi, which does not cause
   // heap allocation.
   StoreSmi(&raw_ptr()->hash_, Smi::New(value));
 }
 
 }  // namespace dart
 
 #endif  // VM_OBJECT_H_