v8::internal::StartupSerializer Class Reference

#include <serialize.h>

Inheritance diagram for v8::internal::StartupSerializer:

Collaboration diagram for v8::internal::StartupSerializer:

Public Member Functions
	StartupSerializer (Isolate *isolate, SnapshotByteSink *sink)
virtual void	SerializeStrongReferences ()
virtual void	SerializeObject (Object *o, HowToCode how_to_code, WhereToPoint where_to_point, int skip)
void	SerializeWeakReferences ()
void	Serialize ()
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
	DISALLOW_COPY_AND_ASSIGN (StartupSerializer)

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 546 of file serialize.h.

Constructor & Destructor Documentation

StartupSerializer()

v8::internal::StartupSerializer::StartupSerializer ( Isolate *  isolate, SnapshotByteSink *  sink  )

inline

Definition at line 548 of file serialize.h.

    : Serializer(isolate, sink) {
    // Clear the cache of objects used by the partial snapshot.  After the
    // strong roots have been serialized we can create a partial snapshot
    // which will repopulate the cache with objects needed by that partial
    // snapshot.
    isolate->set_serialize_partial_snapshot_cache_length(0);
    InitializeCodeAddressMap();
  }

References v8::internal::Serializer::InitializeCodeAddressMap(), and v8::internal::Serializer::isolate().

Here is the call graph for this function:

Member Function Documentation

DISALLOW_COPY_AND_ASSIGN()

v8::internal::StartupSerializer::DISALLOW_COPY_AND_ASSIGN ( StartupSerializer  )

private

Serialize()

void v8::internal::StartupSerializer::Serialize ( )

inline

Definition at line 567 of file serialize.h.

                   {
    SerializeStrongReferences();
    SerializeWeakReferences();
    Pad();
  }

References v8::internal::Serializer::Pad(), SerializeStrongReferences(), and SerializeWeakReferences().

Here is the call graph for this function:

SerializeObject()

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

virtual

Implements v8::internal::Serializer.

Definition at line 1380 of file serialize.cc.

              {
  CHECK(o->IsHeapObject());
  HeapObject* heap_object = HeapObject::cast(o);
  DCHECK(!heap_object->IsJSFunction());
 
  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 (address_mapper_.IsMapped(heap_object)) {
    SerializeReferenceToPreviousObject(heap_object, how_to_code, where_to_point,
                                       skip);
  } else {
    if (skip != 0) {
      sink_->Put(kSkip, "FlushPendingSkip");
      sink_->PutInt(skip, "SkipDistance");
    }
 
    // Object has not yet been serialized.  Serialize it here.
    ObjectSerializer object_serializer(this,
                                       heap_object,
                                       sink_,
                                       how_to_code,
                                       where_to_point);
    object_serializer.Serialize();
  }
}

References v8::internal::Serializer::address_mapper_, CHECK, DCHECK, v8::internal::SerializationAddressMapper::IsMapped(), v8::internal::Serializer::kInvalidRootIndex, v8::internal::SerializerDeserializer::kSkip, 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(), and v8::internal::Serializer::sink_.

Here is the call graph for this function:

SerializeStrongReferences()

void v8::internal::StartupSerializer::SerializeStrongReferences ( )

virtual

Definition at line 1233 of file serialize.cc.

                                                  {
  Isolate* isolate = this->isolate();
  // No active threads.
  CHECK_EQ(NULL, isolate->thread_manager()->FirstThreadStateInUse());
  // No active or weak handles.
  CHECK(isolate->handle_scope_implementer()->blocks()->is_empty());
  CHECK_EQ(0, isolate->global_handles()->NumberOfWeakHandles());
  CHECK_EQ(0, isolate->eternal_handles()->NumberOfHandles());
  // We don't support serializing installed extensions.
  CHECK(!isolate->has_installed_extensions());
  isolate->heap()->IterateSmiRoots(this);
  isolate->heap()->IterateStrongRoots(this, VISIT_ONLY_STRONG);
}

References v8::internal::HandleScopeImplementer::blocks(), CHECK, CHECK_EQ, v8::internal::Isolate::eternal_handles(), v8::internal::ThreadManager::FirstThreadStateInUse(), v8::internal::Isolate::global_handles(), v8::internal::Isolate::handle_scope_implementer(), v8::internal::Isolate::has_installed_extensions(), v8::internal::Isolate::heap(), v8::internal::Serializer::isolate(), v8::internal::Heap::IterateSmiRoots(), v8::internal::Heap::IterateStrongRoots(), NULL, v8::internal::EternalHandles::NumberOfHandles(), v8::internal::GlobalHandles::NumberOfWeakHandles(), v8::internal::Isolate::thread_manager(), and v8::internal::VISIT_ONLY_STRONG.

Referenced by main(), and Serialize().

Here is the call graph for this function:

Here is the caller graph for this function:

SerializeWeakReferences()

void v8::internal::StartupSerializer::SerializeWeakReferences

(

)

Definition at line 1415 of file serialize.cc.

                                                {
  // This phase comes right after the partial serialization (of the snapshot).
  // After we have done the partial serialization the partial snapshot cache
  // will contain some references needed to decode the partial snapshot.  We
  // add one entry with 'undefined' which is the sentinel that the deserializer
  // uses to know it is done deserializing the array.
  Object* undefined = isolate()->heap()->undefined_value();
  VisitPointer(&undefined);
  isolate()->heap()->IterateWeakRoots(this, VISIT_ALL);
  Pad();
}

References v8::internal::Isolate::heap(), v8::internal::Serializer::isolate(), v8::internal::Heap::IterateWeakRoots(), v8::internal::Serializer::Pad(), and v8::internal::VISIT_ALL.

Referenced by main(), and Serialize().

Here is the call graph for this function:

Here is the caller graph for this function:

---

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

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