Use clustered serialization for full snapshots.

runtime/vm/raw_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_RAW_OBJECT_H_
 #define VM_RAW_OBJECT_H_
 
 #include "platform/assert.h"
 #include "vm/atomic.h"
 #include "vm/globals.h"
@@ skipping 591 matching lines @@
     VerifiedMemory::Write(const_cast<RawSmi**>(addr), value);
   }
 
 #if defined(DEBUG)
   static void ValidateOverwrittenPointer(RawObject* raw);
   static void ValidateOverwrittenSmi(RawSmi* raw);
 #endif  // DEBUG
 
   friend class Api;
   friend class ApiMessageReader;  // GetClassId
+  friend class Serializer;  // GetClassId
   friend class Array;
   friend class Bigint;
   friend class ByteBuffer;
   friend class Closure;
   friend class Code;
   friend class Double;
   friend class ForwardPointersVisitor;  // StorePointer
   friend class FreeListElement;
   friend class Function;
   friend class GCMarker;
@@ skipping 15 matching lines @@
   friend class Scavenger;
   friend class ScavengerVisitor;
   friend class SizeExcludingClassVisitor;  // GetClassId
   friend class InstanceAccumulator;  // GetClassId
   friend class RetainingPathVisitor;  // GetClassId
   friend class SkippedCodeFunctions;  // StorePointer
   friend class InstructionsReader;  // tags_ check
   friend class AssemblyInstructionsWriter;
   friend class BlobInstructionsWriter;
   friend class SnapshotReader;
+  friend class Deserializer;
   friend class SnapshotWriter;
   friend class String;
   friend class Type;  // GetClassId
   friend class TypedData;
   friend class TypedDataView;
   friend class WeakProperty;  // StorePointer
   friend class Instance;  // StorePointer
   friend class StackFrame;  // GetCodeObject assertion.
   friend class CodeLookupTableBuilder;  // profiler
   friend class NativeEntry;  // GetClassId
@@ skipping 66 matching lines @@
   int16_t num_own_type_arguments_;  // Number of non-overlapping type arguments.
   uint16_t num_native_fields_;  // Number of native fields in class.
   uint16_t state_bits_;
 
   friend class Instance;
   friend class Isolate;
   friend class Object;
   friend class RawInstance;
   friend class RawInstructions;
   friend class SnapshotReader;
+  friend class ClassSerializationCluster;
+  friend class ClassDeserializationCluster;
+  friend class InstanceSerializationCluster;
 };
 
 
 class RawUnresolvedClass : public RawObject {
   RAW_HEAP_OBJECT_IMPLEMENTATION(UnresolvedClass);
 
   RawObject** from() {
     return reinterpret_cast<RawObject**>(&ptr()->library_prefix_);
   }
   RawLibraryPrefix* library_prefix_;  // Library prefix qualifier for the ident.
   RawString* ident_;  // Name of the unresolved identifier.
   RawObject** to() {
     return reinterpret_cast<RawObject**>(&ptr()->ident_);
   }
   TokenPosition token_pos_;
+
+  friend class UnresolvedClassSerializationCluster;

[Florian Schneider, 2016/06/14 20:32:20]

Have you tried making these friend declarations part of the
RAW_HEAP_OBJECT_IMPLEMENTATION macro?

[rmacnak, 2016/06/21 17:53:03]

Done.

+  friend class UnresolvedClassDeserializationCluster;
 };
 
 
 class RawTypeArguments : public RawObject {
  private:
   RAW_HEAP_OBJECT_IMPLEMENTATION(TypeArguments);
 
   RawObject** from() {
     return reinterpret_cast<RawObject**>(&ptr()->instantiations_);
   }
@@ skipping 11 matching lines @@
     OPEN_ARRAY_START(RawAbstractType*, RawAbstractType*);
   }
   RawAbstractType** types() {
     OPEN_ARRAY_START(RawAbstractType*, RawAbstractType*);
   }
   RawObject** to(intptr_t length) {
     return reinterpret_cast<RawObject**>(&ptr()->types()[length - 1]);
   }
 
   friend class SnapshotReader;
+  friend class TypeArgumentsSerializationCluster;
+  friend class TypeArgumentsDeserializationCluster;
 };
 
 
 class RawPatchClass : public RawObject {
  private:
   RAW_HEAP_OBJECT_IMPLEMENTATION(PatchClass);
 
   RawObject** from() {
     return reinterpret_cast<RawObject**>(&ptr()->patched_class_);
   }
   RawClass* patched_class_;
   RawClass* origin_class_;
   RawScript* script_;
   RawObject** to() {
     return reinterpret_cast<RawObject**>(&ptr()->script_);
   }
 
   friend class Function;
+  friend class PatchClassSerializationCluster;
+  friend class PatchClassDeserializationCluster;
 };
 
 
 class RawFunction : public RawObject {
  public:
   enum Kind {
     kRegularFunction,
     kClosureFunction,
     kSignatureFunction,  // represents a signature only without actual code.
     kGetterFunction,     // represents getter functions e.g: get foo() { .. }.
@@ skipping 15 matching lines @@
     kGeneratorBit =  0x2,
     kAsync      = kAsyncBit,
     kSyncGen    = kGeneratorBit,
     kAsyncGen   = kAsyncBit | kGeneratorBit,
   };
 
  private:
   // So that the SkippedCodeFunctions::DetachCode can null out the code fields.
   friend class SkippedCodeFunctions;
   friend class Class;
+  friend class FunctionSerializationCluster;
+  friend class FunctionDeserializationCluster;
+
   RAW_HEAP_OBJECT_IMPLEMENTATION(Function);
+
   static bool ShouldVisitCode(RawCode* raw_code);
   static bool CheckUsageCounter(RawFunction* raw_fun);
 
   RawObject** from() { return reinterpret_cast<RawObject**>(&ptr()->name_); }
   RawString* name_;
   RawObject* owner_;  // Class or patch class or mixin class
                       // where this function is defined.
   RawAbstractType* result_type_;
   RawArray* parameter_types_;
   RawArray* parameter_names_;
@@ skipping 34 matching lines @@
   }
   RawContextScope* context_scope_;
   RawFunction* parent_function_;  // Enclosing function of this local function.
   RawType* signature_type_;
   RawInstance* closure_;  // Closure object for static implicit closures.
   RawObject** to() {
     return reinterpret_cast<RawObject**>(&ptr()->closure_);
   }
 
   friend class Function;
+  friend class ClosureDataSerializationCluster;
+  friend class ClosureDataDeserializationCluster;
 };
 
 
 class RawRedirectionData : public RawObject {
  private:
   RAW_HEAP_OBJECT_IMPLEMENTATION(RedirectionData);
 
   RawObject** from() {
     return reinterpret_cast<RawObject**>(&ptr()->type_);
   }
   RawType* type_;
   RawString* identifier_;
   RawFunction* target_;
   RawObject** to() {
     return reinterpret_cast<RawObject**>(&ptr()->target_);
   }
+
+  friend class RedirectionDataSerializationCluster;
+  friend class RedirectionDataDeserializationCluster;
 };
 
 
 class RawField : public RawObject {
   RAW_HEAP_OBJECT_IMPLEMENTATION(Field);
 
   RawObject** from() { return reinterpret_cast<RawObject**>(&ptr()->name_); }
   RawString* name_;
   RawObject* owner_;  // Class or patch class or mixin class
                       // where this field is defined or original field.
@@ skipping 36 matching lines @@
   TokenPosition token_pos_;
   classid_t guarded_cid_;
   classid_t is_nullable_;  // kNullCid if field can contain null value and
                            // any other value otherwise.
   // Offset to the guarded length field inside an instance of class matching
   // guarded_cid_. Stored corrected by -kHeapObjectTag to simplify code
   // generated on platforms with weak addressing modes (ARM, MIPS).
   int8_t guarded_list_length_in_object_offset_;
 
   uint8_t kind_bits_;  // static, final, const, has initializer....
+
+  friend class FieldSerializationCluster;
+  friend class FieldDeserializationCluster;
 };
 
 
 class RawLiteralToken : public RawObject {
   RAW_HEAP_OBJECT_IMPLEMENTATION(LiteralToken);
 
   RawObject** from() {
     return reinterpret_cast<RawObject**>(&ptr()->literal_);
   }
   RawString* literal_;  // Literal characters as they appear in source text.
   RawObject* value_;  // The actual object corresponding to the token.
   RawObject** to() {
     return reinterpret_cast<RawObject**>(&ptr()->value_);
   }
   Token::Kind kind_;  // The literal kind (string, integer, double).
 
   friend class SnapshotReader;
+  friend class LiteralTokenSerializationCluster;
+  friend class LiteralTokenDeserializationCluster;
 };
 
 
 class RawTokenStream : public RawObject {
   RAW_HEAP_OBJECT_IMPLEMENTATION(TokenStream);
 
   RawObject** from() {
     return reinterpret_cast<RawObject**>(&ptr()->private_key_);
   }
   RawString* private_key_;  // Key used for private identifiers.
   RawGrowableObjectArray* token_objects_;
   RawExternalTypedData* stream_;
   RawObject** to() {
     return reinterpret_cast<RawObject**>(&ptr()->stream_);
   }
 
   friend class SnapshotReader;
+  friend class TokenStreamSerializationCluster;
+  friend class TokenStreamDeserializationCluster;
 };
 
 
 class RawScript : public RawObject {
  public:
   enum Kind {
     kScriptTag = 0,
     kLibraryTag,
     kSourceTag,
     kPatchTag,
@@ skipping 22 matching lines @@
         break;
     }
     UNREACHABLE();
     return NULL;
   }
 
   int32_t line_offset_;
   int32_t col_offset_;
   int8_t kind_;  // Of type Kind.
   int64_t load_timestamp_;
+
+  friend class ScriptSerializationCluster;
+  friend class ScriptDeserializationCluster;
 };
 
 
 class RawLibrary : public RawObject {
   enum LibraryState {
     kAllocated,       // Initial state.
     kLoadRequested,   // Compiler or script requested load of library.
     kLoadInProgress,  // Library is in the process of being loaded.
     kLoaded,          // Library is loaded.
     kLoadError,       // Error occurred during load of the Library.
@@ skipping 27 matching lines @@
   classid_t index_;              // Library id number.
   uint16_t num_imports_;         // Number of entries in imports_.
   int8_t load_state_;            // Of type LibraryState.
   bool corelib_imported_;
   bool is_dart_scheme_;
   bool debuggable_;              // True if debugger can stop in library.
   bool is_in_fullsnapshot_;      // True if library is in a full snapshot.
 
   friend class Class;
   friend class Isolate;
+  friend class LibrarySerializationCluster;
+  friend class LibraryDeserializationCluster;
 };
 
 
 class RawNamespace : public RawObject {
   RAW_HEAP_OBJECT_IMPLEMENTATION(Namespace);
 
   RawObject** from() {
     return reinterpret_cast<RawObject**>(&ptr()->library_);
   }
   RawLibrary* library_;          // library with name dictionary.
   RawArray* show_names_;         // list of names that are exported.
   RawArray* hide_names_;         // blacklist of names that are not exported.
   RawField* metadata_field_;     // remembers the token pos of metadata if any,
                                  // and the metadata values if computed.
   RawObject** to() {
     return reinterpret_cast<RawObject**>(&ptr()->metadata_field_);
   }
+
+  friend class NamespaceSerializationCluster;
+  friend class NamespaceDeserializationCluster;
 };
 
 
 class RawCode : public RawObject {
   enum InlinedMetadataIndex {
     kInlinedIntervalsIndex = 0,
     kInlinedIdToFunctionIndex = 1,
     kInlinedCallerIdMapIndex = 2,
     kInlinedIdToTokenPosIndex = 3,
     kInlinedMetadataSize = 4,
@@ skipping 45 matching lines @@
   int32_t* data() { OPEN_ARRAY_START(int32_t, int32_t); }
   const int32_t* data() const { OPEN_ARRAY_START(int32_t, int32_t); }
 
   static bool ContainsPC(RawObject* raw_obj, uword pc);
 
   friend class Function;
   template<bool> friend class MarkingVisitorBase;
   friend class SkippedCodeFunctions;
   friend class StackFrame;
   friend class Profiler;
+  friend class CodeSerializationCluster;
+  friend class CodeDeserializationCluster;
+  friend class FunctionDeserializationCluster;
 };
 
 
 class RawObjectPool : public RawObject {
   RAW_HEAP_OBJECT_IMPLEMENTATION(ObjectPool);
 
   intptr_t length_;
   RawTypedData* info_array_;
 
   struct Entry {
     union {
       RawObject* raw_obj_;
       uword raw_value_;
     };
   };
   Entry* data() { OPEN_ARRAY_START(Entry, Entry); }
   Entry const* data() const { OPEN_ARRAY_START(Entry, Entry); }
 
   Entry* first_entry() { return &ptr()->data()[0]; }
 
   friend class Object;
   friend class SnapshotReader;
+  friend class ObjectPoolSerializationCluster;
+  friend class ObjectPoolDeserializationCluster;
 };
 
 
 class RawInstructions : public RawObject {
   RAW_HEAP_OBJECT_IMPLEMENTATION(Instructions);
 
   int32_t size_;
 
   // Variable length data follows here.
   uint8_t* data() { OPEN_ARRAY_START(uint8_t, uint8_t); }
@@ skipping 212 matching lines @@
   // Array with [num_entries_] entries. Each entry is an array of all handled
   // exception types.
   RawArray* handled_types_data_;
 
   // Exception handler info of length [num_entries_].
   const HandlerInfo* data() const { OPEN_ARRAY_START(HandlerInfo, intptr_t); }
   HandlerInfo* data() { OPEN_ARRAY_START(HandlerInfo, intptr_t); }
 
   friend class Object;
   friend class SnapshotReader;
+  friend class ExceptionHandlersSerializationCluster;
+  friend class ExceptionHandlersDeserializationCluster;
 };
 
 
 class RawContext : public RawObject {
   RAW_HEAP_OBJECT_IMPLEMENTATION(Context);
 
   int32_t num_variables_;
 
   RawObject** from() { return reinterpret_cast<RawObject**>(&ptr()->parent_); }
   RawContext* parent_;
 
   // Variable length data follows here.
   RawObject** data() { OPEN_ARRAY_START(RawObject*, RawObject*); }
   RawObject* const* data() const {
       OPEN_ARRAY_START(RawObject*, RawObject*);
   }
   RawObject** to(intptr_t num_vars) {
     return reinterpret_cast<RawObject**>(&ptr()->data()[num_vars - 1]);
   }
 
   friend class SnapshotReader;
+  friend class ContextSerializationCluster;
+  friend class ContextDeserializationCluster;
 };
 
 
 class RawContextScope : public RawObject {
   RAW_HEAP_OBJECT_IMPLEMENTATION(ContextScope);
 
   // TODO(iposva): Switch to conventional enum offset based structure to avoid
   // alignment mishaps.
   struct VariableDesc {
     RawSmi* token_pos;
@@ skipping 24 matching lines @@
   }
   RawObject** to(intptr_t num_vars) {
     uword end = reinterpret_cast<uword>(ptr()->VariableDescAddr(num_vars));
     // 'end' is the address just beyond the last descriptor, so step back.
     return reinterpret_cast<RawObject**>(end - kWordSize);
   }
 
   friend class Object;
   friend class RawClosureData;
   friend class SnapshotReader;
+  friend class ContextScopeSerializationCluster;
+  friend class ContextScopeDeserializationCluster;
 };
 
 
 class RawICData : public RawObject {
   RAW_HEAP_OBJECT_IMPLEMENTATION(ICData);
 
   RawObject** from() {
     return reinterpret_cast<RawObject**>(&ptr()->ic_data_);
   }
   RawArray* ic_data_;  // Contains class-ids, target and count.
@@ skipping 19 matching lines @@
     UNREACHABLE();
     return NULL;
   }
   int32_t deopt_id_;     // Deoptimization id corresponding to this IC.
   uint32_t state_bits_;  // Number of arguments tested in IC, deopt reasons,
                          // range feedback.
 #if defined(TAG_IC_DATA)
   intptr_t tag_;  // Debugging, verifying that the icdata is assigned to the
                   // same instruction again. Store -1 or Instruction::Tag.
 #endif
+
+  friend class ICDataSerializationCluster;
+  friend class ICDataDeserializationCluster;
 };
 
 
 class RawMegamorphicCache : public RawObject {
   RAW_HEAP_OBJECT_IMPLEMENTATION(MegamorphicCache);
 
   RawObject** from() {
     return reinterpret_cast<RawObject**>(&ptr()->buckets_);
   }
   RawArray* buckets_;
   RawSmi* mask_;
   RawString* target_name_;     // Name of target function.
   RawArray* args_descriptor_;  // Arguments descriptor.
   RawObject** to() {
     return reinterpret_cast<RawObject**>(&ptr()->args_descriptor_);
   }
 
   int32_t filled_entry_count_;
+
+  friend class MegamorphicCacheSerializationCluster;
+  friend class MegamorphicCacheDeserializationCluster;
 };
 
 
 class RawSubtypeTestCache : public RawObject {
   RAW_HEAP_OBJECT_IMPLEMENTATION(SubtypeTestCache);
   RawArray* cache_;
+
+  friend class SubtypeTestCacheSerializationCluster;
+  friend class SubtypeTestCacheDeserializationCluster;
 };
 
 
 class RawError : public RawObject {
   RAW_HEAP_OBJECT_IMPLEMENTATION(Error);
 };
 
 
 class RawApiError : public RawError {
   RAW_HEAP_OBJECT_IMPLEMENTATION(ApiError);
@@ skipping 17 matching lines @@
   RawError* previous_error_;  // May be null.
   RawScript* script_;
   RawString* message_;
   RawString* formatted_message_;  // Incl. previous error's formatted message.
   RawObject** to() {
     return reinterpret_cast<RawObject**>(&ptr()->formatted_message_);
   }
   TokenPosition token_pos_;  // Source position in script_.
   bool report_after_token_;  // Report message at or after the token.
   int8_t kind_;  // Of type LanguageError::Kind.
+
+  friend class LanguageErrorSerializationCluster;
+  friend class LanguageErrorDeserializationCluster;
 };
 
 
 class RawUnhandledException : public RawError {
   RAW_HEAP_OBJECT_IMPLEMENTATION(UnhandledException);
 
   RawObject** from() {
     return reinterpret_cast<RawObject**>(&ptr()->exception_);
   }
   RawInstance* exception_;
   RawInstance* stacktrace_;
   RawObject** to() {
     return reinterpret_cast<RawObject**>(&ptr()->stacktrace_);
   }
+
+  friend class UnhandledExceptionSerializationCluster;
+  friend class UnhandledExceptionDeserializationCluster;
 };
 
 
 class RawUnwindError : public RawError {
   RAW_HEAP_OBJECT_IMPLEMENTATION(UnwindError);
 
   RawObject** from() {
     return reinterpret_cast<RawObject**>(&ptr()->message_);
   }
   RawString* message_;
   RawObject** to() {
     return reinterpret_cast<RawObject**>(&ptr()->message_);
   }
   bool is_user_initiated_;
   bool is_vm_restart_;
 };
 
 
 class RawInstance : public RawObject {
   RAW_HEAP_OBJECT_IMPLEMENTATION(Instance);
+
+  friend class InstanceSerializationCluster;
+  friend class InstanceDeserializationCluster;
 };
 
 
 class RawLibraryPrefix : public RawInstance {
   RAW_HEAP_OBJECT_IMPLEMENTATION(LibraryPrefix);
 
   RawObject** from() { return reinterpret_cast<RawObject**>(&ptr()->name_); }
   RawString* name_;               // Library prefix name.
   RawLibrary* importer_;          // Library which declares this prefix.
   RawArray* imports_;             // Libraries imported with this prefix.
@@ skipping 14 matching lines @@
       case Snapshot::kNone:
       case Snapshot::kInvalid:
         break;
     }
     UNREACHABLE();
     return NULL;
   }
   uint16_t num_imports_;          // Number of library entries in libraries_.
   bool is_deferred_load_;
   bool is_loaded_;
+
+  friend class LibraryPrefixSerializationCluster;
+  friend class LibraryPrefixDeserializationCluster;
 };
 
 
 class RawAbstractType : public RawInstance {
  protected:
   enum TypeState {
     kAllocated,  // Initial state.
     kResolved,  // Type class and type arguments resolved.
     kBeingFinalized,  // In the process of being finalized.
     kFinalizedInstantiated,  // Instantiated type ready for use.
@@ skipping 26 matching lines @@
   // can describe the issue without needing the signature.
   union {
     RawFunction* signature_;  // If not null, this type is a function type.
     RawLanguageError* error_;  // If not null, type is malformed or malbounded.
   } sig_or_err_;
   RawObject** to() {
     return reinterpret_cast<RawObject**>(&ptr()->sig_or_err_.error_);
   }
   TokenPosition token_pos_;
   int8_t type_state_;
+
+  friend class TypeSerializationCluster;
+  friend class TypeDeserializationCluster;
 };
 
 
 class RawTypeRef : public RawAbstractType {
  private:
   RAW_HEAP_OBJECT_IMPLEMENTATION(TypeRef);
 
   RawObject** from() {
     return reinterpret_cast<RawObject**>(&ptr()->type_);
   }
   RawAbstractType* type_;  // The referenced type.
   RawObject** to() {
     return reinterpret_cast<RawObject**>(&ptr()->type_);
   }
+
+  friend class TypeRefSerializationCluster;
+  friend class TypeRefDeserializationCluster;
 };
 
 
 class RawTypeParameter : public RawAbstractType {
  private:
   RAW_HEAP_OBJECT_IMPLEMENTATION(TypeParameter);
 
   RawObject** from() {
     return reinterpret_cast<RawObject**>(&ptr()->name_);
   }
   RawString* name_;
   RawSmi* hash_;
   RawAbstractType* bound_;  // ObjectType if no explicit bound specified.
   RawObject** to() { return reinterpret_cast<RawObject**>(&ptr()->bound_); }
   classid_t parameterized_class_id_;
   TokenPosition token_pos_;
   int16_t index_;
   int8_t type_state_;
+
+  friend class TypeParameterSerializationCluster;
+  friend class TypeParameterDeserializationCluster;
 };
 
 
 class RawBoundedType : public RawAbstractType {
  private:
   RAW_HEAP_OBJECT_IMPLEMENTATION(BoundedType);
 
   RawObject** from() {
     return reinterpret_cast<RawObject**>(&ptr()->type_);
   }
   RawAbstractType* type_;
   RawAbstractType* bound_;
   RawSmi* hash_;
   RawTypeParameter* type_parameter_;  // For more detailed error reporting.
   RawObject** to() {
     return reinterpret_cast<RawObject**>(&ptr()->type_parameter_);
   }
+
+  friend class BoundedTypeSerializationCluster;
+  friend class BoundedTypeDeserializationCluster;
 };
 
 
 class RawMixinAppType : public RawAbstractType {
  private:
   RAW_HEAP_OBJECT_IMPLEMENTATION(MixinAppType);
 
   RawObject** from() {
     return reinterpret_cast<RawObject**>(&ptr()->super_type_);
   }
@@ skipping 14 matching lines @@
     return reinterpret_cast<RawObject**>(&ptr()->type_arguments_);
   }
 
   RawTypeArguments* type_arguments_;
   RawFunction* function_;
   RawContext* context_;
 
   RawObject** to() {
     return reinterpret_cast<RawObject**>(&ptr()->context_);
   }
+
+  friend class ClosureSerializationCluster;
+  friend class ClosureDeserializationCluster;
 };
 
 
 class RawNumber : public RawInstance {
   RAW_OBJECT_IMPLEMENTATION(Number);
 };
 
 
 class RawInteger : public RawNumber {
   RAW_OBJECT_IMPLEMENTATION(Integer);
 };
 
 
 class RawSmi : public RawInteger {
   RAW_OBJECT_IMPLEMENTATION(Smi);
 };
 
 
 class RawMint : public RawInteger {
   RAW_HEAP_OBJECT_IMPLEMENTATION(Mint);
 
   ALIGN8 int64_t value_;
 
   friend class Api;
   friend class SnapshotReader;
+  friend class SmiMintSerializationCluster;
+  friend class SmiMintDeserializationCluster;
 };
 COMPILE_ASSERT(sizeof(RawMint) == 16);
 
 
 class RawBigint : public RawInteger {
   RAW_HEAP_OBJECT_IMPLEMENTATION(Bigint);
 
   RawObject** from() { return reinterpret_cast<RawObject**>(&ptr()->neg_); }
   RawBool* neg_;
   RawSmi* used_;
   RawTypedData* digits_;
   RawObject** to() { return reinterpret_cast<RawObject**>(&ptr()->digits_); }
+
+  friend class BigintSerializationCluster;
+  friend class BigintDeserializationCluster;
 };
 
 
 class RawDouble : public RawNumber {
   RAW_HEAP_OBJECT_IMPLEMENTATION(Double);
 
   ALIGN8 double value_;
 
   friend class Api;
   friend class SnapshotReader;
+  friend class DoubleSerializationCluster;
+  friend class DoubleDeserializationCluster;
 };
 COMPILE_ASSERT(sizeof(RawDouble) == 16);
 
 
 class RawString : public RawInstance {
   RAW_HEAP_OBJECT_IMPLEMENTATION(String);
 
  protected:
   RawObject** from() { return reinterpret_cast<RawObject**>(&ptr()->length_); }
   RawSmi* length_;
   RawSmi* hash_;
   RawObject** to() { return reinterpret_cast<RawObject**>(&ptr()->hash_); }
 
   friend class Library;
 };
 
 
 class RawOneByteString : public RawString {
   RAW_HEAP_OBJECT_IMPLEMENTATION(OneByteString);
 
   // Variable length data follows here.
   uint8_t* data() { OPEN_ARRAY_START(uint8_t, uint8_t); }
   const uint8_t* data() const { OPEN_ARRAY_START(uint8_t, uint8_t); }
 
   friend class ApiMessageReader;
   friend class SnapshotReader;
+  friend class OneByteStringSerializationCluster;
+  friend class OneByteStringDeserializationCluster;
+  friend class RODataSerializationCluster;
 };
 
 
 class RawTwoByteString : public RawString {
   RAW_HEAP_OBJECT_IMPLEMENTATION(TwoByteString);
 
   // Variable length data follows here.
   uint16_t* data() { OPEN_ARRAY_START(uint16_t, uint16_t); }
   const uint16_t* data() const { OPEN_ARRAY_START(uint16_t, uint16_t); }
 
   friend class SnapshotReader;
+  friend class TwoByteStringSerializationCluster;
+  friend class TwoByteStringDeserializationCluster;
+  friend class RODataSerializationCluster;
 };
 
 
 template<typename T>
 class ExternalStringData {
  public:
   ExternalStringData(const T* data, void* peer, Dart_PeerFinalizer callback) :
       data_(data), peer_(peer), callback_(callback) {
   }
   ~ExternalStringData() {
@@ skipping 55 matching lines @@
   }
   RawTypeArguments* type_arguments_;
   RawSmi* length_;
   // Variable length data follows here.
   RawObject** data() { OPEN_ARRAY_START(RawObject*, RawObject*); }
   RawObject* const* data() const { OPEN_ARRAY_START(RawObject*, RawObject*); }
   RawObject** to(intptr_t length) {
     return reinterpret_cast<RawObject**>(&ptr()->data()[length - 1]);
   }
 
+  friend class ArraySerializationCluster;
+  friend class ArrayDeserializationCluster;
+  friend class LinkedHashMapSerializationCluster;
+  friend class LinkedHashMapDeserializationCluster;
+  friend class Deserializer;
   friend class RawCode;
   friend class RawImmutableArray;
   friend class SnapshotReader;
   friend class GrowableObjectArray;
   friend class LinkedHashMap;
   friend class RawLinkedHashMap;
   friend class Object;
   friend class ICData;  // For high performance access.
   friend class SubtypeTestCache;  // For high performance access.
 };
@@ skipping 13 matching lines @@
     return reinterpret_cast<RawObject**>(&ptr()->type_arguments_);
   }
   RawTypeArguments* type_arguments_;
   RawSmi* length_;
   RawArray* data_;
   RawObject** to() {
     return reinterpret_cast<RawObject**>(&ptr()->data_);
   }
 
   friend class SnapshotReader;
+  friend class GrowableObjectArraySerializationCluster;
+  friend class GrowableObjectArrayDeserializationCluster;
 };
 
 
 class RawLinkedHashMap : public RawInstance {
   RAW_HEAP_OBJECT_IMPLEMENTATION(LinkedHashMap);
 
   RawObject** from() {
     return reinterpret_cast<RawObject**>(&ptr()->type_arguments_);
   }
   RawTypeArguments* type_arguments_;
   RawTypedData* index_;
   RawSmi* hash_mask_;
   RawArray* data_;
   RawSmi* used_data_;
   RawSmi* deleted_keys_;
   RawObject** to() {
     return reinterpret_cast<RawObject**>(&ptr()->deleted_keys_);
   }
 
-
   friend class SnapshotReader;
+  friend class LinkedHashMapSerializationCluster;
+  friend class LinkedHashMapDeserializationCluster;
 };
 
 
 class RawFloat32x4 : public RawInstance {
   RAW_HEAP_OBJECT_IMPLEMENTATION(Float32x4);
 
   ALIGN8 float value_[4];
 
   friend class SnapshotReader;
+
  public:
   float x() const { return value_[0]; }
   float y() const { return value_[1]; }
   float z() const { return value_[2]; }
   float w() const { return value_[3]; }
 };
 COMPILE_ASSERT(sizeof(RawFloat32x4) == 24);
 
 
 class RawInt32x4 : public RawInstance {
   RAW_HEAP_OBJECT_IMPLEMENTATION(Int32x4);
 
   ALIGN8 int32_t value_[4];
 
   friend class SnapshotReader;
+
  public:
   int32_t x() const { return value_[0]; }
   int32_t y() const { return value_[1]; }
   int32_t z() const { return value_[2]; }
   int32_t w() const { return value_[3]; }
 };
 COMPILE_ASSERT(sizeof(RawInt32x4) == 24);
 
 
 class RawFloat64x2 : public RawInstance {
   RAW_HEAP_OBJECT_IMPLEMENTATION(Float64x2);
 
   ALIGN8 double value_[2];
 
   friend class SnapshotReader;
+
  public:
   double x() const { return value_[0]; }
   double y() const { return value_[1]; }
 };
 COMPILE_ASSERT(sizeof(RawFloat64x2) == 24);
 
 
 // Define an aliases for intptr_t.
 #if defined(ARCH_IS_32_BIT)
 #define kIntPtrCid kTypedDataInt32ArrayCid
@@ skipping 16 matching lines @@
   uint8_t* data() { OPEN_ARRAY_START(uint8_t, uint8_t); }
   const uint8_t* data() const { OPEN_ARRAY_START(uint8_t, uint8_t); }
   RawObject** to() { return reinterpret_cast<RawObject**>(&ptr()->length_); }
 
   friend class Api;
   friend class Object;
   friend class Instance;
   friend class SnapshotReader;
   friend class ObjectPool;
   friend class RawObjectPool;
+  friend class TypedDataSerializationCluster;
+  friend class TypedDataDeserializationCluster;
+  friend class ObjectPoolSerializationCluster;
+  friend class ObjectPoolDeserializationCluster;
 };
 
 
 class RawExternalTypedData : public RawInstance {
   RAW_HEAP_OBJECT_IMPLEMENTATION(ExternalTypedData);
 
  protected:
   RawObject** from() { return reinterpret_cast<RawObject**>(&ptr()->length_); }
   RawSmi* length_;
   RawObject** to() { return reinterpret_cast<RawObject**>(&ptr()->length_); }
 
   uint8_t* data_;
 
   friend class TokenStream;
   friend class RawTokenStream;
+  friend class ExternalTypedDataSerializationCluster;
+  friend class ExternalTypedDataDeserializationCluster;
 };
 
 // VM implementations of the basic types in the isolate.
 class RawCapability : public RawInstance {
   RAW_HEAP_OBJECT_IMPLEMENTATION(Capability);
   uint64_t id_;
 };
 
 
 class RawSendPort : public RawInstance {
@@ skipping 29 matching lines @@
   RawObject** from() {
     return reinterpret_cast<RawObject**>(&ptr()->code_array_);
   }
   RawArray* code_array_;  // Code object for each frame in the stack trace.
   RawArray* pc_offset_array_;  // Offset of PC for each frame.
   RawObject** to() {
     return reinterpret_cast<RawObject**>(&ptr()->pc_offset_array_);
   }
   // False for pre-allocated stack trace (used in OOM and Stack overflow).
   bool expand_inlined_;
+
+  friend class StacktraceSerializationCluster;
+  friend class StacktraceDeserializationCluster;
 };
 
 
 // VM type for capturing JS regular expressions.
 class RawRegExp : public RawInstance {
   RAW_HEAP_OBJECT_IMPLEMENTATION(RegExp);
 
   RawObject** from() {
     return reinterpret_cast<RawObject**>(&ptr()->num_bracket_expressions_);
   }
   RawSmi* num_bracket_expressions_;
   RawString* pattern_;  // Pattern to be used for matching.
   RawFunction* one_byte_function_;
   RawFunction* two_byte_function_;
   RawFunction* external_one_byte_function_;
   RawFunction* external_two_byte_function_;
   RawTypedData* one_byte_bytecode_;
   RawTypedData* two_byte_bytecode_;
   RawObject** to() {
     return reinterpret_cast<RawObject**>(&ptr()->two_byte_bytecode_);
   }
 
   intptr_t num_registers_;
 
   // A bitfield with two fields:
   // type: Uninitialized, simple or complex.
   // flags: Represents global/local, case insensitive, multiline.
   int8_t type_flags_;
+
+  friend class RegExpSerializationCluster;
+  friend class RegExpDeserializationCluster;
 };
 
 
 class RawWeakProperty : public RawInstance {
   RAW_HEAP_OBJECT_IMPLEMENTATION(WeakProperty);
 
   RawObject** from() {
     return reinterpret_cast<RawObject**>(&ptr()->key_);
   }
   RawObject* key_;
@@ skipping 262 matching lines @@
   COMPILE_ASSERT(kExternalTypedDataInt8ArrayCid ==
                  kTypedDataInt8ArrayViewCid + 15);
   COMPILE_ASSERT(kByteBufferCid == kExternalTypedDataInt8ArrayCid + 14);
   COMPILE_ASSERT(kNullCid == kByteBufferCid + 1);
   return (kNullCid - kTypedDataInt8ArrayCid);
 }
 
 }  // namespace dart
 
 #endif  // VM_RAW_OBJECT_H_