dart::FieldTable Class Reference

#include <field_table.h>

Public Member Functions
	FieldTable (Isolate *isolate, IsolateGroup *isolate_group=nullptr)
	~FieldTable ()
bool	IsReadyToUse () const
void	MarkReadyToUse ()
intptr_t	NumFieldIds () const
intptr_t	Capacity () const
ObjectPtr *	table ()
void	FreeOldTables ()
bool	IsValidIndex (intptr_t index) const
bool	Register (const Field &field, intptr_t expected_field_id=-1)
void	AllocateIndex (intptr_t index)
void	Free (intptr_t index)
ObjectPtr	At (intptr_t index, bool concurrent_use=false) const
void	SetAt (intptr_t index, ObjectPtr raw_instance, bool concurrent_use=false)
FieldTable *	Clone (Isolate *for_isolate, IsolateGroup *for_isolate_group=nullptr)
void	VisitObjectPointers (ObjectPointerVisitor *visitor)

Static Public Member Functions
static intptr_t	FieldOffsetFor (intptr_t field_id)

Static Public Attributes
static constexpr int	kInitialCapacity = 512
static constexpr int	kCapacityIncrement = 256

Detailed Description

Definition at line 23 of file field_table.h.

Constructor & Destructor Documentation

FieldTable()

dart::FieldTable::FieldTable ( Isolate *  isolate, IsolateGroup *  isolate_group = nullptr  )

inlineexplicit

Definition at line 25 of file field_table.h.

      : top_(0),
        capacity_(0),
        free_head_(-1),
        table_(nullptr),
        old_tables_(new MallocGrowableArray<ObjectPtr*>()),
        isolate_(isolate),
        isolate_group_(isolate_group),
        is_ready_to_use_(isolate == nullptr) {}

~FieldTable()

dart::FieldTable::~FieldTable

(

)

Definition at line 19 of file field_table.cc.

                        {
  FreeOldTables();
  delete old_tables_;  // Allocated in FieldTable::FieldTable()
  free(table_);        // Allocated in FieldTable::Grow()
}

Member Function Documentation

AllocateIndex()

void dart::FieldTable::AllocateIndex

(

intptr_t

index

)

Definition at line 91 of file field_table.cc.

                                             {
  if (index >= capacity_) {
    const intptr_t new_capacity = index + kCapacityIncrement;
    Grow(new_capacity);
  }
 
  ASSERT(table_[index] == ObjectPtr());
  if (index >= top_) {
    top_ = index + 1;
  }
}

At()

ObjectPtr dart::FieldTable::At ( intptr_t  index, bool  concurrent_use = false  ) const

inline

Definition at line 62 of file field_table.h.

                                                                  {
    ASSERT(IsValidIndex(index));
    if (concurrent_use) {
      ObjectPtr* table =
          reinterpret_cast<const AcqRelAtomic<ObjectPtr*>*>(&table_)->load();
      return reinterpret_cast<AcqRelAtomic<ObjectPtr>*>(&table[index])->load();
    } else {
      // There is no concurrent access expected for this field, so we avoid
      // using atomics. This will allow us to detect via TSAN if there are
      // racy uses.
      return table_[index];
    }
  }

Capacity()

intptr_t dart::FieldTable::Capacity ( ) const

inline

Definition at line 41 of file field_table.h.

{ return capacity_; }

Clone()

FieldTable * dart::FieldTable::Clone	(	Isolate *	for_isolate,
		IsolateGroup *	for_isolate_group = nullptr
	)

Definition at line 134 of file field_table.cc.

                                                               {
  DEBUG_ASSERT(
      IsolateGroup::Current()->program_lock()->IsCurrentThreadReader());
 
  FieldTable* clone = new FieldTable(for_isolate, for_isolate_group);
  ASSERT(clone->table_ == nullptr);
  if (table_ == nullptr) {
    ASSERT(capacity_ == 0);
    ASSERT(top_ == 0);
    ASSERT(free_head_ == -1);
  } else {
    auto new_table = static_cast<ObjectPtr*>(
        malloc(capacity_ * sizeof(ObjectPtr)));  // NOLINT
    memmove(new_table, table_, capacity_ * sizeof(ObjectPtr));
    clone->table_ = new_table;
    clone->capacity_ = capacity_;
    clone->top_ = top_;
    clone->free_head_ = free_head_;
  }
  return clone;
}

FieldOffsetFor()

intptr_t dart::FieldTable::FieldOffsetFor ( intptr_t  field_id )

static

Definition at line 51 of file field_table.cc.

                                                     {
  return field_id * sizeof(ObjectPtr);  // NOLINT
}

Free()

void dart::FieldTable::Free

(

intptr_t

index

)

Definition at line 86 of file field_table.cc.

                                       {
  table_[field_id] = Smi::New(free_head_);
  free_head_ = field_id;
}

FreeOldTables()

void dart::FieldTable::FreeOldTables

(

)

Definition at line 45 of file field_table.cc.

                               {
  while (old_tables_->length() > 0) {
    free(old_tables_->RemoveLast());
  }
}

IsReadyToUse()

bool dart::FieldTable::IsReadyToUse

(

)

const

Definition at line 25 of file field_table.cc.

                                    {
  DEBUG_ASSERT(
      IsolateGroup::Current()->IsReloading() ||
      IsolateGroup::Current()->program_lock()->IsCurrentThreadReader());
  return is_ready_to_use_;
}

IsValidIndex()

bool dart::FieldTable::IsValidIndex ( intptr_t  index ) const

inline

Definition at line 50 of file field_table.h.

{ return index >= 0 && index < top_; }

MarkReadyToUse()

void dart::FieldTable::MarkReadyToUse

(

)

Definition at line 32 of file field_table.cc.

                                {
  // The isolate will mark it's field table ready-to-use upon initialization of
  // the isolate. Only after it was marked as ready-to-use will it participate
  // in new static field registrations.
  //
  // By requiring a read lock here we ensure no other thread is is registering a
  // new static field at this moment (it would need exclusive writer lock).
  DEBUG_ASSERT(
      IsolateGroup::Current()->program_lock()->IsCurrentThreadReader());
  ASSERT(!is_ready_to_use_);
  is_ready_to_use_ = true;
}

NumFieldIds()

intptr_t dart::FieldTable::NumFieldIds ( ) const

inline

Definition at line 40 of file field_table.h.

{ return top_; }

Register()

bool dart::FieldTable::Register	(	const Field &	field,
		intptr_t	expected_field_id = -1
	)

Definition at line 55 of file field_table.cc.

                                                                        {
  DEBUG_ASSERT(
      IsolateGroup::Current()->program_lock()->IsCurrentThreadWriter());
  ASSERT(is_ready_to_use_);
 
  if (free_head_ < 0) {
    bool grown_backing_store = false;
    if (top_ == capacity_) {
      const intptr_t new_capacity = capacity_ + kCapacityIncrement;
      Grow(new_capacity);
      grown_backing_store = true;
    }
 
    ASSERT(top_ < capacity_);
    ASSERT(expected_field_id == -1 || expected_field_id == top_);
    field.set_field_id(top_);
    table_[top_] = Object::sentinel().ptr();
 
    ++top_;
    return grown_backing_store;
  }
 
  // Reuse existing free element. This is "slow path" that should only be
  // triggered after hot reload.
  intptr_t reused_free = free_head_;
  free_head_ = Smi::Value(Smi::RawCast(table_[free_head_]));
  field.set_field_id(reused_free);
  table_[reused_free] = Object::sentinel().ptr();
  return false;
}

SetAt()

void dart::FieldTable::SetAt ( intptr_t  index, ObjectPtr  raw_instance, bool  concurrent_use = false  )

inline

Definition at line 76 of file field_table.h.

                                          {
    ASSERT(index < capacity_);
    ObjectPtr* slot = &table_[index];
    if (concurrent_use) {
      reinterpret_cast<AcqRelAtomic<ObjectPtr>*>(slot)->store(raw_instance);
    } else {
      // There is no concurrent access expected for this field, so we avoid
      // using atomics. This will allow us to detect via TSAN if there are
      // racy uses.
      *slot = raw_instance;
    }
  }

table()

ObjectPtr * dart::FieldTable::table ( )

inline

Definition at line 43 of file field_table.h.

{ return table_; }

VisitObjectPointers()

void dart::FieldTable::VisitObjectPointers

(

ObjectPointerVisitor *

visitor

)

Definition at line 157 of file field_table.cc.

                                                                  {
  // GC might try to visit field table before it's isolate done setting it up.
  if (table_ == nullptr) {
    return;
  }
 
  ASSERT(visitor != nullptr);
  visitor->set_gc_root_type("static fields table");
  visitor->VisitPointers(&table_[0], &table_[top_ - 1]);
  visitor->clear_gc_root_type();
}

Member Data Documentation

kCapacityIncrement

constexpr int dart::FieldTable::kCapacityIncrement = 256

staticconstexpr

Definition at line 97 of file field_table.h.

kInitialCapacity

constexpr int dart::FieldTable::kInitialCapacity = 512

staticconstexpr

Definition at line 96 of file field_table.h.

---

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

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