dart::MessageSerializer Class Reference

Inheritance diagram for dart::MessageSerializer:

Public Member Functions
	MessageSerializer (Thread *thread)
	~MessageSerializer ()
bool	MarkObjectId (ObjectPtr object, intptr_t id)
void	SetObjectId (ObjectPtr object, intptr_t id)
intptr_t	GetObjectId (ObjectPtr object) const
DART_NOINLINE void	AddBaseObject (ObjectPtr base_object)
DART_NOINLINE void	AssignRef (ObjectPtr object)
void	AssignRef (Object *object)
void	Push (ObjectPtr object)
void	Trace (const Object &root, Object *object)
void	IllegalObject (const Object &object, const char *message)
void	AddBaseObjects ()
void	Serialize (const Object &root)
DART_NOINLINE void	WriteRef (ObjectPtr object)
Thread *	thread () const
Isolate *	isolate () const
IsolateGroup *	isolate_group () const
bool	HasRef (ObjectPtr object) const
Public Member Functions inherited from dart::BaseSerializer
	BaseSerializer (Thread *thread, Zone *zone)
	~BaseSerializer ()
template<typename T >
void	Write (T value)
void	WriteUnsigned (intptr_t value)
void	WriteWordWith32BitWrites (uword value)
void	WriteBytes (const void *addr, intptr_t len)
void	WriteAscii (const String &str)
MessageSerializationCluster *	NewClusterForClass (intptr_t cid, bool is_canonical)
void	WriteCluster (MessageSerializationCluster *cluster)
std::unique_ptr< Message >	Finish (Dart_Port dest_port, Message::Priority priority)
Zone *	zone () const
MessageFinalizableData *	finalizable_data () const
intptr_t	next_ref_index () const
Public Member Functions inherited from dart::StackResource
	StackResource (ThreadState *thread)
virtual	~StackResource ()
ThreadState *	thread () const

Additional Inherited Members
Static Public Member Functions inherited from dart::StackResource
static void	Unwind (ThreadState *thread)
static void	UnwindAbove (ThreadState *thread, StackResource *new_top)
Protected Attributes inherited from dart::BaseSerializer
Zone *const	zone_
MallocWriteStream	stream_
MessageFinalizableData *	finalizable_data_
GrowableArray< MessageSerializationCluster * >	clusters_
intptr_t	num_base_objects_
intptr_t	num_written_objects_
intptr_t	next_ref_index_

Detailed Description

Definition at line 204 of file message_snapshot.cc.

Constructor & Destructor Documentation

MessageSerializer()

dart::MessageSerializer::MessageSerializer ( Thread *  thread )

explicit

Definition at line 2705 of file message_snapshot.cc.

    : BaseSerializer(thread, thread->zone()),
      forward_table_new_(),
      forward_table_old_(),
      stack_(thread->zone(), 0) {
  isolate()->set_forward_table_new(new WeakTable());
  isolate()->set_forward_table_old(new WeakTable());
}

~MessageSerializer()

dart::MessageSerializer::~MessageSerializer

(

)

Definition at line 2714 of file message_snapshot.cc.

                                      {
  isolate()->set_forward_table_new(nullptr);
  isolate()->set_forward_table_old(nullptr);
}

Member Function Documentation

AddBaseObject()

DART_NOINLINE void dart::MessageSerializer::AddBaseObject ( ObjectPtr  base_object )

inline

Definition at line 241 of file message_snapshot.cc.

                                                          {
    AssignRef(base_object);
    num_base_objects_++;
  }

AddBaseObjects()

void dart::MessageSerializer::AddBaseObjects

(

)

Definition at line 3216 of file message_snapshot.cc.

                                       {
  AddBaseObject(Object::null());
  AddBaseObject(Object::sentinel().ptr());
  AddBaseObject(Object::transition_sentinel().ptr());
  AddBaseObject(Object::empty_array().ptr());
  AddBaseObject(Object::dynamic_type().ptr());
  AddBaseObject(Object::void_type().ptr());
  AddBaseObject(Object::empty_type_arguments().ptr());
  AddBaseObject(Bool::True().ptr());
  AddBaseObject(Bool::False().ptr());
}

AssignRef() [1/2]

void dart::MessageSerializer::AssignRef ( Object *  object )

inline

Definition at line 249 of file message_snapshot.cc.

{ AssignRef(object->ptr()); }

AssignRef() [2/2]

DART_NOINLINE void dart::MessageSerializer::AssignRef ( ObjectPtr  object )

inline

Definition at line 245 of file message_snapshot.cc.

                                                 {
    SetObjectId(object, next_ref_index_);
    next_ref_index_++;
  }

GetObjectId()

intptr_t dart::MessageSerializer::GetObjectId ( ObjectPtr  object ) const

inline

Definition at line 231 of file message_snapshot.cc.

                                               {
    const WeakTable* table;
    if (object->IsImmediateOrOldObject()) {
      table = isolate()->forward_table_old();
    } else {
      table = isolate()->forward_table_new();
    }
    return table->GetValueExclusive(object);
  }

HasRef()

bool dart::MessageSerializer::HasRef ( ObjectPtr  object ) const

inline

Definition at line 272 of file message_snapshot.cc.

                                      {
    return GetObjectId(object) != WeakTable::kNoValue;
  }

IllegalObject()

void dart::MessageSerializer::IllegalObject	(	const Object &	object,
		const char *	message
	)

Definition at line 3053 of file message_snapshot.cc.

                                                           {
  const Array& args = Array::Handle(zone(), Array::New(3));
  args.SetAt(0, object);
  args.SetAt(2, String::Handle(zone(), String::New(message)));
  Exceptions::ThrowByType(Exceptions::kArgumentValue, args);
}

isolate()

Isolate * dart::MessageSerializer::isolate ( ) const

inline

Definition at line 269 of file message_snapshot.cc.

{ return thread()->isolate(); }

isolate_group()

IsolateGroup * dart::MessageSerializer::isolate_group ( ) const

inline

Definition at line 270 of file message_snapshot.cc.

{ return thread()->isolate_group(); }

MarkObjectId()

bool dart::MessageSerializer::MarkObjectId ( ObjectPtr  object, intptr_t  id  )

inline

Definition at line 209 of file message_snapshot.cc.

                                                   {
    ASSERT(id != WeakTable::kNoValue);
    WeakTable* table;
    if (object->IsImmediateOrOldObject()) {
      table = isolate()->forward_table_old();
    } else {
      table = isolate()->forward_table_new();
    }
    return table->MarkValueExclusive(object, id);
  }

Push()

void dart::MessageSerializer::Push

(

ObjectPtr

object

)

Definition at line 2724 of file message_snapshot.cc.

                                             {
  if (MarkObjectId(object, kUnallocatedReference)) {
    stack_.Add(&Object::ZoneHandle(zone_, object));
    num_written_objects_++;
  }
}

Serialize()

void dart::MessageSerializer::Serialize

(

const Object &

root

)

Definition at line 3264 of file message_snapshot.cc.

                                                    {
  AddBaseObjects();
 
  Push(root.ptr());
 
  while (stack_.length() > 0) {
    Trace(root, stack_.RemoveLast());
  }
 
  intptr_t num_objects = num_base_objects_ + num_written_objects_;
  WriteUnsigned(num_base_objects_);
  WriteUnsigned(num_objects);
 
  for (intptr_t i = 0; i < static_cast<intptr_t>(MessagePhase::kNumPhases);
       i++) {
    intptr_t num_clusters = 0;
    for (MessageSerializationCluster* cluster : clusters_) {
      if (static_cast<intptr_t>(cluster->phase()) != i) continue;
      num_clusters++;
    }
    WriteUnsigned(num_clusters);
    for (MessageSerializationCluster* cluster : clusters_) {
      if (static_cast<intptr_t>(cluster->phase()) != i) continue;
      WriteCluster(cluster);
      cluster->WriteNodes(this);
    }
    for (MessageSerializationCluster* cluster : clusters_) {
      if (static_cast<intptr_t>(cluster->phase()) != i) continue;
      cluster->WriteEdges(this);
    }
  }
 
  // We should have assigned a ref to every object we pushed.
  ASSERT((next_ref_index_ - 1) == num_objects);
 
  WriteRef(root.ptr());
}

SetObjectId()

void dart::MessageSerializer::SetObjectId ( ObjectPtr  object, intptr_t  id  )

inline

Definition at line 220 of file message_snapshot.cc.

                                                  {
    ASSERT(id != WeakTable::kNoValue);
    WeakTable* table;
    if (object->IsImmediateOrOldObject()) {
      table = isolate()->forward_table_old();
    } else {
      table = isolate()->forward_table_new();
    }
    table->SetValueExclusive(object, id);
  }

thread()

Thread * dart::MessageSerializer::thread ( ) const

inline

Definition at line 266 of file message_snapshot.cc.

                         {
    return static_cast<Thread*>(StackResource::thread());
  }

Trace()

void dart::MessageSerializer::Trace	(	const Object &	root,
		Object *	object
	)

Definition at line 2738 of file message_snapshot.cc.

                                                                {
  intptr_t cid;
  bool is_canonical;
  if (!object->ptr()->IsHeapObject()) {
    cid = kSmiCid;
    is_canonical = true;
  } else {
    cid = object->GetClassId();
    is_canonical = object->ptr()->untag()->IsCanonical();
  }
 
  MessageSerializationCluster* cluster = nullptr;
  for (MessageSerializationCluster* c : clusters_) {
    if ((c->cid() == cid) && (c->is_canonical() == is_canonical)) {
      cluster = c;
      break;
    }
  }
  if (cluster == nullptr) {
    if (cid >= kNumPredefinedCids || cid == kInstanceCid) {
      // Will stomp over forward_table_new/old WeakTables, which should be ok,
      // as they are not going to be used again here.
      const char* message = OS::SCreate(
          zone_, "is a regular instance reachable via %s",
          FindRetainingPath(zone_, isolate(), root, *object,
                            TraversalRules::kExternalBetweenIsolateGroups));
      IllegalObject(*object, message);
    }
 
    const char* illegal_cid_string = nullptr;
    // Keep the list in sync with the one in lib/isolate.cc,
    // vm/object_graph_copy.cc
#define ILLEGAL(type)                                                          \
  case k##type##Cid:                                                           \
    illegal_cid_string = #type;                                                \
    break;
 
    switch (cid) {
      ILLEGAL(Closure)
      ILLEGAL(Finalizer)
      ILLEGAL(FinalizerEntry)
      ILLEGAL(FunctionType)
      ILLEGAL(MirrorReference)
      ILLEGAL(NativeFinalizer)
      ILLEGAL(ReceivePort)
      ILLEGAL(Record)
      ILLEGAL(RecordType)
      ILLEGAL(RegExp)
      ILLEGAL(StackTrace)
      ILLEGAL(SuspendState)
      ILLEGAL(UserTag)
      ILLEGAL(WeakProperty)
      ILLEGAL(WeakReference)
      ILLEGAL(WeakArray)
 
      // From "dart:ffi" we handle only Pointer/DynamicLibrary specially, since
      // those are the only non-abstract classes (so we avoid checking more cids
      // here that cannot happen in reality)
      ILLEGAL(DynamicLibrary)
      ILLEGAL(Pointer)
 
#undef ILLEGAL
    }
 
    if (illegal_cid_string != nullptr) {
      // Will stomp over forward_table_new/old WeakTables, which should be ok,
      // as they are not going to be used again here.
      const char* message = OS::SCreate(
          zone_, "is a %s reachable via %s", illegal_cid_string,
          FindRetainingPath(zone_, isolate(), root, *object,
                            TraversalRules::kExternalBetweenIsolateGroups));
      IllegalObject(*object, message);
    }
 
    cluster = NewClusterForClass(cid, is_canonical);
    clusters_.Add(cluster);
  }
 
  cluster->Trace(this, object);
}

WriteRef()

DART_NOINLINE void dart::MessageSerializer::WriteRef ( ObjectPtr  object )

inline

Definition at line 260 of file message_snapshot.cc.

                                                {
    intptr_t index = GetObjectId(object);
    ASSERT(index != WeakTable::kNoValue);
    WriteUnsigned(index);
  }

---

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

• third_party/dart-lang/sdk/runtime/vm/message_snapshot.cc