v8::internal::PartialSerializer Class Reference

#include <serialize.h>

Inheritance diagram for v8::internal::PartialSerializer:

Collaboration diagram for v8::internal::PartialSerializer:

Public Member Functions
	PartialSerializer (Isolate *isolate, Serializer *startup_snapshot_serializer, SnapshotByteSink *sink)
void	Serialize (Object **o)
virtual void	SerializeObject (Object *o, HowToCode how_to_code, WhereToPoint where_to_point, int skip)
Public Member Functions inherited from v8::internal::Serializer
	Serializer (Isolate *isolate, SnapshotByteSink *sink)
	~Serializer ()
void	VisitPointers (Object **start, Object **end)
int	CurrentAllocationAddress (int space) const
Isolate *	isolate () const
SerializationAddressMapper *	address_mapper ()
void	PutRoot (int index, HeapObject *object, HowToCode how, WhereToPoint where, int skip)

Private Member Functions
int	PartialSnapshotCacheIndex (HeapObject *o)
bool	ShouldBeInThePartialSnapshotCache (HeapObject *o)
	DISALLOW_COPY_AND_ASSIGN (PartialSerializer)

Private Attributes
Serializer *	startup_serializer_

Additional Inherited Members
Static Public Member Functions inherited from v8::internal::SerializerDeserializer
static void	Iterate (Isolate *isolate, ObjectVisitor *visitor)
static int	nop ()
Static Public Attributes inherited from v8::internal::SerializerDeserializer
static const int	kNumberOfPreallocatedSpaces = LO_SPACE
static const int	kNumberOfSpaces = INVALID_SPACE
Protected Types inherited from v8::internal::SerializerDeserializer
enum	Where {   kNewObject = 0 , kRootArray = 0x9 , kPartialSnapshotCache = 0xa , kExternalReference = 0xb ,   kSkip = 0xc , kBuiltin = 0xd , kAttachedReference = 0xe , kNop = 0xf ,   kBackref = 0x10 , kBackrefWithSkip = 0x18 , kPointedToMask = 0x3f }
enum	HowToCode { kPlain = 0 , kFromCode = 0x40 , kHowToCodeMask = 0x40 }
enum	WithSkip { kNoSkipDistance = 0 , kHasSkipDistance = 0x40 , kWithSkipMask = 0x40 }
enum	WhereToPoint { kStartOfObject = 0 , kInnerPointer = 0x80 , kWhereToPointMask = 0x80 }
Protected Member Functions inherited from v8::internal::Serializer
int	RootIndex (HeapObject *heap_object, HowToCode from)
intptr_t	root_index_wave_front ()
void	set_root_index_wave_front (intptr_t value)
void	SerializeReferenceToPreviousObject (HeapObject *heap_object, HowToCode how_to_code, WhereToPoint where_to_point, int skip)
void	InitializeAllocators ()
int	AllocateLargeObject (int size)
int	Allocate (int space, int size)
int	EncodeExternalReference (Address addr)
int	SpaceAreaSize (int space)
bool	ShouldBeSkipped (Object **current)
void	Pad ()
void	InitializeCodeAddressMap ()
Protected Member Functions inherited from v8::internal::SerializerDeserializer
	STATIC_ASSERT (kNumberOfSpaces<=kSpaceMask+1)
Static Protected Member Functions inherited from v8::internal::Serializer
static int	SpaceOfObject (HeapObject *object)
Static Protected Member Functions inherited from v8::internal::SerializerDeserializer
static int	CodeForRepeats (int repeats)
static int	RepeatsForCode (int byte_code)
static int	RootArrayConstantFromByteCode (int byte_code)
Protected Attributes inherited from v8::internal::Serializer
Isolate *	isolate_
int	fullness_ [kNumberOfSpaces]
SnapshotByteSink *	sink_
ExternalReferenceEncoder *	external_reference_encoder_
SerializationAddressMapper	address_mapper_
intptr_t	root_index_wave_front_
Static Protected Attributes inherited from v8::internal::Serializer
static const int	kInvalidRootIndex = -1
Static Protected Attributes inherited from v8::internal::SerializerDeserializer
static const int	kRawData = 0x20
static const int	kSynchronize = 0x70
static const int	kNativesStringResource = 0x71
static const int	kRepeat = 0x72
static const int	kConstantRepeat = 0x73
static const int	kMaxRepeats = 0x7f - 0x72
static const int	kRootArrayConstants = 0xa0
static const int	kRootArrayNumberOfConstantEncodings = 0x20
static const int	kAnyOldSpace = -1
static const int	kSpaceMask = 7

Detailed Description

Definition at line 507 of file serialize.h.

Constructor & Destructor Documentation

PartialSerializer()

v8::internal::PartialSerializer::PartialSerializer ( Isolate *  isolate, Serializer *  startup_snapshot_serializer, SnapshotByteSink *  sink  )

inline

Definition at line 509 of file serialize.h.

    : Serializer(isolate, sink),
      startup_serializer_(startup_snapshot_serializer) {
    set_root_index_wave_front(Heap::kStrongRootListLength);
    InitializeCodeAddressMap();
  }

References v8::internal::Serializer::InitializeCodeAddressMap(), v8::internal::Heap::kStrongRootListLength, and v8::internal::Serializer::set_root_index_wave_front().

Here is the call graph for this function:

Member Function Documentation

DISALLOW_COPY_AND_ASSIGN()

v8::internal::PartialSerializer::DISALLOW_COPY_AND_ASSIGN ( PartialSerializer  )

private

PartialSnapshotCacheIndex()

int v8::internal::PartialSerializer::PartialSnapshotCacheIndex ( HeapObject *  o )

private

Definition at line 1313 of file serialize.cc.

                                                                        {
  Isolate* isolate = this->isolate();
 
  for (int i = 0;
       i < isolate->serialize_partial_snapshot_cache_length();
       i++) {
    Object* entry = isolate->serialize_partial_snapshot_cache()[i];
    if (entry == heap_object) return i;
  }
 
  // We didn't find the object in the cache.  So we add it to the cache and
  // then visit the pointer so that it becomes part of the startup snapshot
  // and we can refer to it from the partial snapshot.
  int length = isolate->serialize_partial_snapshot_cache_length();
  isolate->PushToPartialSnapshotCache(heap_object);
  startup_serializer_->VisitPointer(reinterpret_cast<Object**>(&heap_object));
  // We don't recurse from the startup snapshot generator into the partial
  // snapshot generator.
  DCHECK(length == isolate->serialize_partial_snapshot_cache_length() - 1);
  return length;
}

References DCHECK, v8::internal::Serializer::isolate(), v8::internal::Isolate::PushToPartialSnapshotCache(), and startup_serializer_.

Referenced by SerializeObject().

Here is the call graph for this function:

Here is the caller graph for this function:

Serialize()

void v8::internal::PartialSerializer::Serialize

(

Object **

o

)

Definition at line 1248 of file serialize.cc.

                                                 {
  this->VisitPointer(object);
  Pad();
}

References v8::internal::Serializer::Pad().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

SerializeObject()

void v8::internal::PartialSerializer::SerializeObject ( Object *  o, HowToCode  how_to_code, WhereToPoint  where_to_point, int  skip  )

virtual

Implements v8::internal::Serializer.

Definition at line 1456 of file serialize.cc.

              {
  CHECK(o->IsHeapObject());
  HeapObject* heap_object = HeapObject::cast(o);
 
  if (heap_object->IsMap()) {
    // The code-caches link to context-specific code objects, which
    // the startup and context serializes cannot currently handle.
    DCHECK(Map::cast(heap_object)->code_cache() ==
           heap_object->GetHeap()->empty_fixed_array());
  }
 
  int root_index;
  if ((root_index = RootIndex(heap_object, how_to_code)) != kInvalidRootIndex) {
    PutRoot(root_index, heap_object, how_to_code, where_to_point, skip);
    return;
  }
 
  if (ShouldBeInThePartialSnapshotCache(heap_object)) {
    if (skip != 0) {
      sink_->Put(kSkip, "SkipFromSerializeObject");
      sink_->PutInt(skip, "SkipDistanceFromSerializeObject");
    }
 
    int cache_index = PartialSnapshotCacheIndex(heap_object);
    sink_->Put(kPartialSnapshotCache + how_to_code + where_to_point,
               "PartialSnapshotCache");
    sink_->PutInt(cache_index, "partial_snapshot_cache_index");
    return;
  }
 
  // Pointers from the partial snapshot to the objects in the startup snapshot
  // should go through the root array or through the partial snapshot cache.
  // If this is not the case you may have to add something to the root array.
  DCHECK(!startup_serializer_->address_mapper()->IsMapped(heap_object));
  // All the internalized strings that the partial snapshot needs should be
  // either in the root table or in the partial snapshot cache.
  DCHECK(!heap_object->IsInternalizedString());
 
  if (address_mapper_.IsMapped(heap_object)) {
    SerializeReferenceToPreviousObject(heap_object, how_to_code, where_to_point,
                                       skip);
  } else {
    if (skip != 0) {
      sink_->Put(kSkip, "SkipFromSerializeObject");
      sink_->PutInt(skip, "SkipDistanceFromSerializeObject");
    }
    // Object has not yet been serialized.  Serialize it here.
    ObjectSerializer serializer(this,
                                heap_object,
                                sink_,
                                how_to_code,
                                where_to_point);
    serializer.Serialize();
  }
}

References v8::internal::Serializer::address_mapper(), v8::internal::Serializer::address_mapper_, CHECK, DCHECK, v8::internal::HeapObject::GetHeap(), v8::internal::SerializationAddressMapper::IsMapped(), v8::internal::Serializer::kInvalidRootIndex, v8::internal::SerializerDeserializer::kPartialSnapshotCache, v8::internal::SerializerDeserializer::kSkip, PartialSnapshotCacheIndex(), v8::internal::SnapshotByteSink::Put(), v8::internal::SnapshotByteSink::PutInt(), v8::internal::Serializer::PutRoot(), v8::internal::Serializer::RootIndex(), v8::internal::Serializer::ObjectSerializer::Serialize(), v8::internal::Serializer::SerializeReferenceToPreviousObject(), ShouldBeInThePartialSnapshotCache(), v8::internal::Serializer::sink_, and startup_serializer_.

Here is the call graph for this function:

ShouldBeInThePartialSnapshotCache()

bool v8::internal::PartialSerializer::ShouldBeInThePartialSnapshotCache ( HeapObject *  o )

inlineprivate

Definition at line 527 of file serialize.h.

                                                        {
    // Scripts should be referred only through shared function infos.  We can't
    // allow them to be part of the partial snapshot because they contain a
    // unique ID, and deserializing several partial snapshots containing script
    // would cause dupes.
    DCHECK(!o->IsScript());
    return o->IsName() || o->IsSharedFunctionInfo() ||
           o->IsHeapNumber() || o->IsCode() ||
           o->IsScopeInfo() ||
           o->map() ==
               startup_serializer_->isolate()->heap()->fixed_cow_array_map();
  }

References DCHECK, v8::internal::Isolate::heap(), v8::internal::Serializer::isolate(), v8::internal::HeapObject::map(), and startup_serializer_.

Referenced by SerializeObject().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

startup_serializer_

Serializer* v8::internal::PartialSerializer::startup_serializer_

private

Definition at line 541 of file serialize.h.

Referenced by PartialSnapshotCacheIndex(), SerializeObject(), and ShouldBeInThePartialSnapshotCache().

---

The documentation for this class was generated from the following files:

• /mnt/V8SourceCode/src/serialize.h
• /mnt/V8SourceCode/src/serialize.cc