dart::ClassTable Class Reference

#include <class_table.h>

Inheritance diagram for dart::ClassTable:

Classes
struct	ArrayTraits

Public Member Functions
	ClassTable (ClassTableAllocator *allocator)
	~ClassTable ()
ClassTable *	Clone () const
ClassPtr	At (intptr_t cid) const
int32_t	SizeAt (intptr_t index) const
void	SetAt (intptr_t index, ClassPtr raw_cls)
void	UpdateClassSize (intptr_t cid, ClassPtr raw_cls)
bool	IsValidIndex (intptr_t cid) const
bool	HasValidClassAt (intptr_t cid) const
UnboxedFieldBitmap	GetUnboxedFieldsMapAt (intptr_t cid) const
void	SetUnboxedFieldsMapAt (intptr_t cid, UnboxedFieldBitmap map)
bool	ShouldTraceAllocationFor (intptr_t cid)
void	SetTraceAllocationFor (intptr_t cid, bool trace)
void	SetCollectInstancesFor (intptr_t cid, bool trace)
bool	CollectInstancesFor (intptr_t cid)
void	UpdateCachedAllocationTracingStateTablePointer ()
void	PopulateUserVisibleNames ()
const char *	UserVisibleNameFor (intptr_t cid)
void	SetUserVisibleNameFor (intptr_t cid, const char *name)
intptr_t	NumCids () const
intptr_t	Capacity () const
intptr_t	NumTopLevelCids () const
void	Register (const Class &cls)
void	AllocateIndex (intptr_t index)
void	RegisterTopLevel (const Class &cls)
void	UnregisterTopLevel (intptr_t index)
void	Remap (intptr_t *old_to_new_cids)
void	VisitObjectPointers (ObjectPointerVisitor *visitor)
void	CopySizesFromClassObjects ()
void	Validate ()
void	Print ()
void	AllocationProfilePrintJSON (JSONStream *stream, bool internal)
void	PrintToJSONObject (JSONObject *object)
void	FreeOldTables ()
Public Member Functions inherited from dart::MallocAllocated
	MallocAllocated ()
void *	operator new (size_t size)
void *	operator new[] (size_t size)
void	operator delete (void *pointer)
void	operator delete[] (void *pointer)

Static Public Member Functions
static intptr_t	allocation_tracing_state_table_offset ()
static bool	IsTopLevelCid (intptr_t cid)
static intptr_t	IndexFromTopLevelCid (intptr_t cid)
static intptr_t	CidFromTopLevelIndex (intptr_t index)

Friends
class	ClassTableAllocator
class	Dart
class	IsolateGroup
Isolate *	CreateWithinExistingIsolateGroup (IsolateGroup *group, const char *name, char **error)

Detailed Description

Definition at line 354 of file class_table.h.

Constructor & Destructor Documentation

ClassTable()

dart::ClassTable::ClassTable ( ClassTableAllocator *  allocator )

explicit

Definition at line 22 of file class_table.cc.

    : allocator_(allocator),
      classes_(allocator),
      top_level_classes_(allocator) {
  if (Dart::vm_isolate() == nullptr) {
    classes_.SetNumCidsAndCapacity(kNumPredefinedCids, kInitialCapacity);
  } else {
    // Duplicate the class table from the VM isolate.
    ClassTable* vm_class_table = Dart::vm_isolate_group()->class_table();
    classes_.SetNumCidsAndCapacity(kNumPredefinedCids,
                                   vm_class_table->classes_.capacity());
 
    const auto copy_info_for_cid = [&](intptr_t cid) {
      classes_.At<kClassIndex>(cid) = vm_class_table->At(cid);
      classes_.At<kSizeIndex>(cid) = vm_class_table->SizeAt(cid);
    };
 
    // The following cids don't have a corresponding class object in Dart code.
    // We therefore need to initialize them eagerly.
    COMPILE_ASSERT(kFirstInternalOnlyCid == kObjectCid + 1);
    for (intptr_t i = kObjectCid; i <= kLastInternalOnlyCid; i++) {
      copy_info_for_cid(i);
    }
    copy_info_for_cid(kTypeArgumentsCid);
    copy_info_for_cid(kFreeListElement);
    copy_info_for_cid(kForwardingCorpse);
    copy_info_for_cid(kDynamicCid);
    copy_info_for_cid(kVoidCid);
  }
  UpdateCachedAllocationTracingStateTablePointer();
}

~ClassTable()

dart::ClassTable::~ClassTable

(

)

Definition at line 54 of file class_table.cc.

                        {
#if !defined(PRODUCT) || defined(FORCE_INCLUDE_SAMPLING_HEAP_PROFILER)
  for (intptr_t i = 1; i < classes_.num_cids(); i++) {
    const char* name = UserVisibleNameFor(i);
    if (name != nullptr) {
      free(const_cast<char*>(name));
    }
  }
#endif  // !defined(PRODUCT) || defined(FORCE_INCLUDE_SAMPLING_HEAP_PROFILER)
}

Member Function Documentation

AllocateIndex()

void dart::ClassTable::AllocateIndex

(

intptr_t

index

)

Definition at line 102 of file class_table.cc.

                                             {
  bool did_grow = false;
  if (IsTopLevelCid(index)) {
    top_level_classes_.AllocateIndex(IndexFromTopLevelCid(index), &did_grow);
    return;
  }
 
  classes_.AllocateIndex(index, &did_grow);
  if (did_grow) {
    IsolateGroup::Current()->set_cached_class_table_table(table());
    UpdateCachedAllocationTracingStateTablePointer();
  }
}

allocation_tracing_state_table_offset()

static intptr_t dart::ClassTable::allocation_tracing_state_table_offset ( )

inlinestatic

Definition at line 483 of file class_table.h.

                                                          {
    static_assert(sizeof(cached_allocation_tracing_state_table_) == kWordSize);
    return OFFSET_OF(ClassTable, cached_allocation_tracing_state_table_);
  }

AllocationProfilePrintJSON()

void dart::ClassTable::AllocationProfilePrintJSON	(	JSONStream *	stream,
		bool	internal
	)

Definition at line 305 of file class_table.cc.

                                                                             {
  Isolate* isolate = Isolate::Current();
  ASSERT(isolate != nullptr);
  auto isolate_group = isolate->group();
  Heap* heap = isolate_group->heap();
  ASSERT(heap != nullptr);
  JSONObject obj(stream);
  obj.AddProperty("type", "AllocationProfile");
  if (isolate_group->last_allocationprofile_accumulator_reset_timestamp() !=
      0) {
    obj.AddPropertyF(
        "dateLastAccumulatorReset", "%" Pd64 "",
        isolate_group->last_allocationprofile_accumulator_reset_timestamp());
  }
  if (isolate_group->last_allocationprofile_gc_timestamp() != 0) {
    obj.AddPropertyF("dateLastServiceGC", "%" Pd64 "",
                     isolate_group->last_allocationprofile_gc_timestamp());
  }
 
  if (internal) {
    JSONObject heaps(&obj, "_heaps");
    {
      heap->PrintToJSONObject(Heap::kNew, &heaps);
    }
    {
      heap->PrintToJSONObject(Heap::kOld, &heaps);
    }
  }
 
  {
    JSONObject memory(&obj, "memoryUsage");
    {
      heap->PrintMemoryUsageJSON(&memory);
    }
  }
 
  Thread* thread = Thread::Current();
  CountObjectsVisitor visitor(thread, NumCids());
  {
    HeapIterationScope iter(thread);
    iter.IterateObjects(&visitor);
    isolate->group()->VisitWeakPersistentHandles(&visitor);
  }
 
  {
    JSONArray arr(&obj, "members");
    Class& cls = Class::Handle();
    for (intptr_t i = 3; i < classes_.num_cids(); i++) {
      if (!HasValidClassAt(i)) continue;
 
      cls = At(i);
      if (cls.IsNull()) continue;
 
      JSONObject obj(&arr);
      obj.AddProperty("type", "ClassHeapStats");
      obj.AddProperty("class", cls);
      intptr_t count = visitor.new_count_[i] + visitor.old_count_[i];
      intptr_t size = visitor.new_size_[i] + visitor.old_size_[i];
      obj.AddProperty64("instancesAccumulated", count);
      obj.AddProperty64("accumulatedSize", size);
      obj.AddProperty64("instancesCurrent", count);
      obj.AddProperty64("bytesCurrent", size);
 
      if (internal) {
        {
          JSONArray new_stats(&obj, "_new");
          new_stats.AddValue(visitor.new_count_[i]);
          new_stats.AddValue(visitor.new_size_[i]);
          new_stats.AddValue(visitor.new_external_size_[i]);
        }
        {
          JSONArray old_stats(&obj, "_old");
          old_stats.AddValue(visitor.old_count_[i]);
          old_stats.AddValue(visitor.old_size_[i]);
          old_stats.AddValue(visitor.old_external_size_[i]);
        }
      }
    }
  }
}

At()

ClassPtr dart::ClassTable::At ( intptr_t  cid ) const

inline

Definition at line 362 of file class_table.h.

                                  {
    if (IsTopLevelCid(cid)) {
      return top_level_classes_.At<kClassIndex>(IndexFromTopLevelCid(cid));
    }
    return classes_.At<kClassIndex>(cid);
  }

Capacity()

intptr_t dart::ClassTable::Capacity ( ) const

inline

Definition at line 448 of file class_table.h.

{ return classes_.capacity(); }

CidFromTopLevelIndex()

static intptr_t dart::ClassTable::CidFromTopLevelIndex ( intptr_t  index )

inlinestatic

Definition at line 503 of file class_table.h.

                                                       {
    return kTopLevelCidOffset + index;
  }

Clone()

ClassTable * dart::ClassTable::Clone ( ) const

inline

Definition at line 360 of file class_table.h.

{ return new ClassTable(*this); }

CollectInstancesFor()

bool dart::ClassTable::CollectInstancesFor ( intptr_t  cid )

inline

Definition at line 418 of file class_table.h.

                                         {
    auto& slot = classes_.At<kAllocationTracingStateIndex>(cid);
    return (slot & kCollectInstancesBit) != 0;
  }

CopySizesFromClassObjects()

void dart::ClassTable::CopySizesFromClassObjects

(

)

Definition at line 146 of file class_table.cc.

                                           {
  ASSERT(kIllegalCid == 0);
  for (intptr_t i = 1; i < classes_.num_cids(); i++) {
    UpdateClassSize(i, classes_.At<kClassIndex>(i));
  }
}

FreeOldTables()

void dart::ClassTable::FreeOldTables

(

)

GetUnboxedFieldsMapAt()

UnboxedFieldBitmap dart::ClassTable::GetUnboxedFieldsMapAt ( intptr_t  cid ) const

inline

Definition at line 388 of file class_table.h.

                                                               {
    ASSERT(IsValidIndex(cid));
    return classes_.At<kUnboxedFieldBitmapIndex>(cid);
  }

HasValidClassAt()

bool dart::ClassTable::HasValidClassAt ( intptr_t  cid ) const

inline

Definition at line 386 of file class_table.h.

{ return At(cid) != nullptr; }

IndexFromTopLevelCid()

static intptr_t dart::ClassTable::IndexFromTopLevelCid ( intptr_t  cid )

inlinestatic

Definition at line 498 of file class_table.h.

                                                     {
    ASSERT(IsTopLevelCid(cid));
    return cid - kTopLevelCidOffset;
  }

IsTopLevelCid()

static bool dart::ClassTable::IsTopLevelCid ( intptr_t  cid )

inlinestatic

Definition at line 496 of file class_table.h.

{ return cid >= kTopLevelCidOffset; }

IsValidIndex()

bool dart::ClassTable::IsValidIndex ( intptr_t  cid ) const

inline

Definition at line 379 of file class_table.h.

                                        {
    if (IsTopLevelCid(cid)) {
      return top_level_classes_.IsValidIndex(IndexFromTopLevelCid(cid));
    }
    return classes_.IsValidIndex(cid);
  }

NumCids()

intptr_t dart::ClassTable::NumCids ( ) const

inline

Definition at line 447 of file class_table.h.

{ return classes_.num_cids(); }

NumTopLevelCids()

intptr_t dart::ClassTable::NumTopLevelCids ( ) const

inline

Definition at line 450 of file class_table.h.

{ return top_level_classes_.num_cids(); }

PopulateUserVisibleNames()

void dart::ClassTable::PopulateUserVisibleNames

(

)

Definition at line 278 of file class_table.cc.

                                          {
  Class& cls = Class::Handle();
  for (intptr_t i = 0; i < classes_.num_cids(); ++i) {
    if (HasValidClassAt(i) && UserVisibleNameFor(i) == nullptr) {
      cls = At(i);
      cls.SetUserVisibleNameInClassTable();
    }
  }
}

Print()

void dart::ClassTable::Print

(

)

Definition at line 197 of file class_table.cc.

                       {
  Class& cls = Class::Handle();
  String& name = String::Handle();
 
  for (intptr_t i = 1; i < classes_.num_cids(); i++) {
    if (!HasValidClassAt(i)) {
      continue;
    }
    cls = At(i);
    if (cls.ptr() != nullptr) {
      name = cls.Name();
      OS::PrintErr("%" Pd ": %s\n", i, name.ToCString());
    }
  }
}

PrintToJSONObject()

void dart::ClassTable::PrintToJSONObject

(

JSONObject *

object

)

Definition at line 291 of file class_table.cc.

                                                     {
  Class& cls = Class::Handle();
  object->AddProperty("type", "ClassList");
  {
    JSONArray members(object, "classes");
    for (intptr_t i = ClassId::kObjectCid; i < classes_.num_cids(); i++) {
      if (HasValidClassAt(i)) {
        cls = At(i);
        members.AddValue(cls);
      }
    }
  }
}

Register()

void dart::ClassTable::Register

(

const Class &

cls

)

Definition at line 65 of file class_table.cc.

                                          {
  ASSERT(Thread::Current()->IsDartMutatorThread());
  ASSERT(cls.id() == kIllegalCid || cls.id() < kNumPredefinedCids);
  bool did_grow = false;
  const classid_t cid =
      cls.id() != kIllegalCid ? cls.id() : classes_.AddRow(&did_grow);
  ASSERT(!IsTopLevelCid(cid));
 
  const intptr_t instance_size =
      cls.is_abstract() ? 0 : Class::host_instance_size(cls.ptr());
 
  cls.set_id(cid);
  classes_.At<kClassIndex>(cid) = cls.ptr();
  classes_.At<kSizeIndex>(cid) = static_cast<int32_t>(instance_size);
#if !defined(PRODUCT) || defined(FORCE_INCLUDE_SAMPLING_HEAP_PROFILER)
  classes_.At<kClassNameIndex>(cid) = nullptr;
#endif  // !defined(PRODUCT) || defined(FORCE_INCLUDE_SAMPLING_HEAP_PROFILER)
 
  if (did_grow) {
    IsolateGroup::Current()->set_cached_class_table_table(
        classes_.GetColumn<kClassIndex>());
    UpdateCachedAllocationTracingStateTablePointer();
  } else {
    std::atomic_thread_fence(std::memory_order_release);
  }
}

RegisterTopLevel()

void dart::ClassTable::RegisterTopLevel

(

const Class &

cls

)

Definition at line 92 of file class_table.cc.

                                                  {
  ASSERT(Thread::Current()->IsDartMutatorThread());
  ASSERT(cls.id() == kIllegalCid);
 
  bool did_grow = false;
  const intptr_t index = top_level_classes_.AddRow(&did_grow);
  cls.set_id(ClassTable::CidFromTopLevelIndex(index));
  top_level_classes_.At<kClassIndex>(index) = cls.ptr();
}

Remap()

void dart::ClassTable::Remap

(

intptr_t *

old_to_new_cids

)

Definition at line 122 of file class_table.cc.

                                               {
  ASSERT(Thread::Current()->OwnsSafepoint());
  classes_.Remap(old_to_new_cid);
}

SetAt()

void dart::ClassTable::SetAt	(	intptr_t	index,
		ClassPtr	raw_cls
	)

Definition at line 153 of file class_table.cc.

                                                     {
  if (IsTopLevelCid(cid)) {
    top_level_classes_.At<kClassIndex>(IndexFromTopLevelCid(cid)) = raw_cls;
    return;
  }
 
  // This is called by snapshot reader and class finalizer.
  UpdateClassSize(cid, raw_cls);
  classes_.At<kClassIndex>(cid) = raw_cls;
}

SetCollectInstancesFor()

void dart::ClassTable::SetCollectInstancesFor ( intptr_t  cid, bool  trace  )

inline

Definition at line 409 of file class_table.h.

                                                        {
    auto& slot = classes_.At<kAllocationTracingStateIndex>(cid);
    if (trace) {
      slot |= kCollectInstancesBit;
    } else {
      slot &= ~kCollectInstancesBit;
    }
  }

SetTraceAllocationFor()

void dart::ClassTable::SetTraceAllocationFor ( intptr_t  cid, bool  trace  )

inline

Definition at line 404 of file class_table.h.

                                                       {
    classes_.At<kAllocationTracingStateIndex>(cid) =
        trace ? kTraceAllocationBit : kTracingDisabled;
  }

SetUnboxedFieldsMapAt()

void dart::ClassTable::SetUnboxedFieldsMapAt ( intptr_t  cid, UnboxedFieldBitmap  map  )

inline

Definition at line 393 of file class_table.h.

                                                                   {
    ASSERT(IsValidIndex(cid));
    classes_.At<kUnboxedFieldBitmapIndex>(cid) = map;
  }

SetUserVisibleNameFor()

void dart::ClassTable::SetUserVisibleNameFor ( intptr_t  cid, const char *  name  )

inline

Definition at line 441 of file class_table.h.

                                                             {
    ASSERT(classes_.At<kClassNameIndex>(cid) == nullptr);
    classes_.At<kClassNameIndex>(cid) = name;
  }

ShouldTraceAllocationFor()

bool dart::ClassTable::ShouldTraceAllocationFor ( intptr_t  cid )

inline

Definition at line 399 of file class_table.h.

                                              {
    return !IsTopLevelCid(cid) &&
           (classes_.At<kAllocationTracingStateIndex>(cid) != kTracingDisabled);
  }

SizeAt()

int32_t dart::ClassTable::SizeAt ( intptr_t  index ) const

inline

Definition at line 369 of file class_table.h.

                                       {
    if (IsTopLevelCid(index)) {
      return 0;
    }
    return classes_.At<kSizeIndex>(index);
  }

UnregisterTopLevel()

void dart::ClassTable::UnregisterTopLevel

(

intptr_t

index

)

Definition at line 116 of file class_table.cc.

                                                {
  ASSERT(IsTopLevelCid(cid));
  const intptr_t tlc_index = IndexFromTopLevelCid(cid);
  top_level_classes_.At<kClassIndex>(tlc_index) = nullptr;
}

UpdateCachedAllocationTracingStateTablePointer()

void dart::ClassTable::UpdateCachedAllocationTracingStateTablePointer ( )

inline

Definition at line 423 of file class_table.h.

                                                        {
    cached_allocation_tracing_state_table_.store(
        classes_.GetColumn<kAllocationTracingStateIndex>());
  }

UpdateClassSize()

void dart::ClassTable::UpdateClassSize	(	intptr_t	cid,
		ClassPtr	raw_cls
	)

Definition at line 164 of file class_table.cc.

                                                               {
  ASSERT(IsolateGroup::Current()->program_lock()->IsCurrentThreadWriter());
  ASSERT(!IsTopLevelCid(cid));  // "top-level" classes don't get instantiated
  const intptr_t size =
      raw_cls == nullptr ? 0 : Class::host_instance_size(raw_cls);
  classes_.At<kSizeIndex>(cid) = static_cast<int32_t>(size);
}

UserVisibleNameFor()

const char * dart::ClassTable::UserVisibleNameFor ( intptr_t  cid )

inline

Definition at line 434 of file class_table.h.

                                               {
    if (!classes_.IsValidIndex(cid)) {
      return nullptr;
    }
    return classes_.At<kClassNameIndex>(cid);
  }

Validate()

void dart::ClassTable::Validate

(

)

Definition at line 172 of file class_table.cc.

                          {
  Class& cls = Class::Handle();
  for (intptr_t cid = kNumPredefinedCids; cid < classes_.num_cids(); cid++) {
    // Some of the class table entries maybe nullptr as we create some
    // top level classes but do not add them to the list of anonymous
    // classes in a library if there are no top level fields or functions.
    // Since there are no references to these top level classes they are
    // not written into a full snapshot and will not be recreated when
    // we read back the full snapshot. These class slots end up with nullptr
    // entries.
    if (HasValidClassAt(cid)) {
      cls = At(cid);
      ASSERT(cls.IsClass());
#if defined(DART_PRECOMPILER)
      // Precompiler can drop classes and set their id() to kIllegalCid.
      // It still leaves them in the class table so dropped program
      // structure could still be accessed while writing debug info.
      ASSERT((cls.id() == cid) || (cls.id() == kIllegalCid));
#else
      ASSERT(cls.id() == cid);
#endif  // defined(DART_PRECOMPILER)
    }
  }
}

VisitObjectPointers()

void dart::ClassTable::VisitObjectPointers

(

ObjectPointerVisitor *

visitor

)

Definition at line 127 of file class_table.cc.

                                                                  {
  ASSERT(visitor != nullptr);
  visitor->set_gc_root_type("class table");
 
  const auto visit = [&](ClassPtr* table, intptr_t num_cids) {
    if (num_cids == 0) {
      return;
    }
    ObjectPtr* from = reinterpret_cast<ObjectPtr*>(&table[0]);
    ObjectPtr* to = reinterpret_cast<ObjectPtr*>(&table[num_cids - 1]);
    visitor->VisitPointers(from, to);
  };
 
  visit(classes_.GetColumn<kClassIndex>(), classes_.num_cids());
  visit(top_level_classes_.GetColumn<kClassIndex>(),
        top_level_classes_.num_cids());
  visitor->clear_gc_root_type();
}

Friends And Related Function Documentation

ClassTableAllocator

friend class ClassTableAllocator

friend

Definition at line 508 of file class_table.h.

CreateWithinExistingIsolateGroup

Isolate * CreateWithinExistingIsolateGroup ( IsolateGroup *  group, const char *  name, char **  error  )

friend

Definition at line 1301 of file dart_api_impl.cc.

                                                        {
  API_TIMELINE_DURATION(Thread::Current());
  CHECK_NO_ISOLATE(Isolate::Current());
 
  auto spawning_group = group;
 
  Isolate* isolate = reinterpret_cast<Isolate*>(
      CreateIsolate(spawning_group, /*is_new_group=*/false, name,
                    /*isolate_data=*/nullptr, error));
  if (isolate == nullptr) return nullptr;
 
  auto source = spawning_group->source();
  ASSERT(isolate->source() == source);
 
  return isolate;
}

Dart

friend class Dart

friend

Definition at line 509 of file class_table.h.

IsolateGroup

friend class IsolateGroup

friend

Definition at line 513 of file class_table.h.

---

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

• third_party/dart-lang/sdk/runtime/vm/class_table.h
• third_party/dart-lang/sdk/runtime/vm/class_table.cc