dart::WeakTable Class Reference

#include <weak_table.h>

Public Member Functions
	WeakTable ()
	WeakTable (intptr_t size)
	~WeakTable ()
intptr_t	size () const
intptr_t	used () const
intptr_t	count () const
intptr_t	GetValue (ObjectPtr key)
void	SetValue (ObjectPtr key, intptr_t val)
intptr_t	SetValueIfNonExistent (ObjectPtr key, intptr_t val)
bool	IsValidEntryAtExclusive (intptr_t i) const
void	InvalidateAtExclusive (intptr_t i)
ObjectPtr	ObjectAtExclusive (intptr_t i) const
intptr_t	ValueAtExclusive (intptr_t i) const
void	SetValueExclusive (ObjectPtr key, intptr_t val)
bool	MarkValueExclusive (ObjectPtr key, intptr_t val)
intptr_t	GetValueExclusive (ObjectPtr key) const
intptr_t	RemoveValueExclusive (ObjectPtr key)
void	Forward (ObjectPointerVisitor *visitor)
void	ReportSurvivingAllocations (Dart_HeapSamplingReportCallback callback, void *context)
void	CleanupValues (Dart_HeapSamplingDeleteCallback cleanup)
void	Reset ()

Static Public Member Functions
static WeakTable *	NewFrom (WeakTable *original)

Static Public Attributes
static constexpr intptr_t	kNoValue = 0

Detailed Description

Definition at line 16 of file weak_table.h.

Constructor & Destructor Documentation

WeakTable() [1/2]

dart::WeakTable::WeakTable ( )

inline

Definition at line 20 of file weak_table.h.

: WeakTable(kMinSize) {}

WeakTable() [2/2]

dart::WeakTable::WeakTable ( intptr_t  size )

inlineexplicit

Definition at line 21 of file weak_table.h.

                                    : used_(0), count_(0) {
    ASSERT(size >= 0);
    ASSERT(Utils::IsPowerOfTwo(kMinSize));
    if (size < kMinSize) {
      size = kMinSize;
    }
    // Get a max size that avoids overflows.
    const intptr_t kMaxSize =
        (kIntptrOne << (kBitsPerWord - 2)) / (kEntrySize * kWordSize);
    ASSERT(Utils::IsPowerOfTwo(kMaxSize));
    if (size > kMaxSize) {
      size = kMaxSize;
    }
    size_ = size;
    ASSERT(Utils::IsPowerOfTwo(size_));
    data_ = reinterpret_cast<intptr_t*>(malloc(size_ * kEntrySize * kWordSize));
    for (intptr_t i = 0; i < size_; i++) {
      data_[ObjectIndex(i)] = kNoEntry;
      data_[ValueIndex(i)] = kNoValue;
    }
  }

~WeakTable()

dart::WeakTable::~WeakTable ( )

inline

Definition at line 43 of file weak_table.h.

{ free(data_); }

Member Function Documentation

CleanupValues()

void dart::WeakTable::CleanupValues

(

Dart_HeapSamplingDeleteCallback

cleanup

)

Definition at line 156 of file weak_table.cc.

                                                                     {
  for (intptr_t i = 0; i < size_; i++) {
    if (IsValidEntryAtExclusive(i)) {
      cleanup(reinterpret_cast<void*>(data_[ValueIndex(i)]));
    }
  }
}

count()

intptr_t dart::WeakTable::count ( ) const

inline

Definition at line 51 of file weak_table.h.

{ return count_; }

Forward()

void dart::WeakTable::Forward

(

ObjectPointerVisitor *

visitor

)

Definition at line 131 of file weak_table.cc.

                                                     {
  if (used_ == 0) return;
 
  for (intptr_t i = 0; i < size_; i++) {
    if (IsValidEntryAtExclusive(i)) {
      visitor->VisitPointer(ObjectPointerAt(i));
    }
  }
 
  Rehash();
}

GetValue()

intptr_t dart::WeakTable::GetValue ( ObjectPtr  key )

inline

Definition at line 55 of file weak_table.h.

                                   {
    MutexLocker ml(&mutex_);
    return GetValueExclusive(key);
  }

GetValueExclusive()

intptr_t dart::WeakTable::GetValueExclusive ( ObjectPtr  key ) const

inline

Definition at line 109 of file weak_table.h.

                                                  {
    intptr_t mask = size() - 1;
    intptr_t idx = Hash(key) & mask;
    ObjectPtr obj = ObjectAtExclusive(idx);
    while (obj != static_cast<ObjectPtr>(kNoEntry)) {
      if (obj == key) {
        return ValueAtExclusive(idx);
      }
      idx = (idx + 1) & mask;
      obj = ObjectAtExclusive(idx);
    }
    ASSERT(ValueAtExclusive(idx) == 0);
    return kNoValue;
  }

InvalidateAtExclusive()

void dart::WeakTable::InvalidateAtExclusive ( intptr_t  i )

inline

Definition at line 89 of file weak_table.h.

                                         {
    ASSERT(IsValidEntryAtExclusive(i));
    SetValueAt(i, 0);
  }

IsValidEntryAtExclusive()

bool dart::WeakTable::IsValidEntryAtExclusive ( intptr_t  i ) const

inline

Definition at line 80 of file weak_table.h.

                                                 {
    ASSERT((ValueAtExclusive(i) == 0 &&
            (data_[ObjectIndex(i)] == kNoEntry ||
             data_[ObjectIndex(i)] == kDeletedEntry)) ||
           (ValueAtExclusive(i) != 0 && data_[ObjectIndex(i)] != kNoEntry &&
            data_[ObjectIndex(i)] != kDeletedEntry));
    return (data_[ValueIndex(i)] != 0);
  }

MarkValueExclusive()

bool dart::WeakTable::MarkValueExclusive	(	ObjectPtr	key,
		intptr_t	val
	)

Definition at line 78 of file weak_table.cc.

                                                              {
  const intptr_t mask = size() - 1;
  intptr_t idx = Hash(key) & mask;
  intptr_t empty_idx = -1;
  ObjectPtr obj = ObjectAtExclusive(idx);
 
  while (obj != static_cast<ObjectPtr>(kNoEntry)) {
    if (obj == key) {
      return false;
    } else if ((empty_idx < 0) &&
               (static_cast<intptr_t>(obj) == kDeletedEntry)) {
      empty_idx = idx;  // Insert at this location if not found.
    }
    idx = (idx + 1) & mask;
    obj = ObjectAtExclusive(idx);
  }
 
  ASSERT(val != 0);
 
  if (empty_idx >= 0) {
    // We will be reusing a slot below.
    set_used(used() - 1);
    idx = empty_idx;
  }
 
  ASSERT(!IsValidEntryAtExclusive(idx));
  // Set the key and value.
  SetObjectAt(idx, key);
  SetValueAt(idx, val);
  // Update the counts.
  set_used(used() + 1);
  set_count(count() + 1);
 
  // Rehash if needed to ensure that there are empty slots available.
  if (used_ >= limit()) {
    Rehash();
  }
  return true;
}

NewFrom()

static WeakTable * dart::WeakTable::NewFrom ( WeakTable *  original )

inlinestatic

Definition at line 45 of file weak_table.h.

                                                 {
    return new WeakTable(SizeFor(original->count(), original->size()));
  }

ObjectAtExclusive()

ObjectPtr dart::WeakTable::ObjectAtExclusive ( intptr_t  i ) const

inline

Definition at line 94 of file weak_table.h.

                                                {
    ASSERT(i >= 0);
    ASSERT(i < size());
    return static_cast<ObjectPtr>(data_[ObjectIndex(i)]);
  }

RemoveValueExclusive()

intptr_t dart::WeakTable::RemoveValueExclusive ( ObjectPtr  key )

inline

Definition at line 126 of file weak_table.h.

                                               {
    intptr_t mask = size() - 1;
    intptr_t idx = Hash(key) & mask;
    ObjectPtr obj = ObjectAtExclusive(idx);
    while (obj != static_cast<ObjectPtr>(kNoEntry)) {
      if (obj == key) {
        intptr_t result = ValueAtExclusive(idx);
        InvalidateAtExclusive(idx);
        return result;
      }
      idx = (idx + 1) & mask;
      obj = ObjectAtExclusive(idx);
    }
    ASSERT(ValueAtExclusive(idx) == 0);
    return kNoValue;
  }

ReportSurvivingAllocations()

void dart::WeakTable::ReportSurvivingAllocations	(	Dart_HeapSamplingReportCallback	callback,
		void *	context
	)

Definition at line 144 of file weak_table.cc.

                   {
  MutexLocker ml(&mutex_);
  for (intptr_t i = 0; i < size_; i++) {
    if (IsValidEntryAtExclusive(i)) {
      void* data = reinterpret_cast<void*>(data_[ValueIndex(i)]);
      callback(context, data);
    }
  }
}

Reset()

void dart::WeakTable::Reset

(

)

Definition at line 118 of file weak_table.cc.

                      {
  intptr_t* old_data = data_;
  used_ = 0;
  count_ = 0;
  size_ = kMinSize;
  free(old_data);
  data_ = reinterpret_cast<intptr_t*>(malloc(size_ * kEntrySize * kWordSize));
  for (intptr_t i = 0; i < size_; i++) {
    data_[ObjectIndex(i)] = kNoEntry;
    data_[ValueIndex(i)] = kNoValue;
  }
}

SetValue()

void dart::WeakTable::SetValue ( ObjectPtr  key, intptr_t  val  )

inline

Definition at line 60 of file weak_table.h.

                                             {
    MutexLocker ml(&mutex_);
    return SetValueExclusive(key, val);
  }

SetValueExclusive()

void dart::WeakTable::SetValueExclusive	(	ObjectPtr	key,
		intptr_t	val
	)

Definition at line 33 of file weak_table.cc.

                                                             {
  const intptr_t mask = size() - 1;
  intptr_t idx = Hash(key) & mask;
  intptr_t empty_idx = -1;
  ObjectPtr obj = ObjectAtExclusive(idx);
 
  while (obj != static_cast<ObjectPtr>(kNoEntry)) {
    if (obj == key) {
      SetValueAt(idx, val);
      return;
    } else if ((empty_idx < 0) &&
               (static_cast<intptr_t>(obj) == kDeletedEntry)) {
      empty_idx = idx;  // Insert at this location if not found.
    }
    idx = (idx + 1) & mask;
    obj = ObjectAtExclusive(idx);
  }
 
  if (val == 0) {
    // Do not enter an invalid value. Associating 0 with a key deletes it from
    // this weak table above in SetValueAt. If the key was not present in the
    // weak table we are done.
    return;
  }
 
  if (empty_idx >= 0) {
    // We will be reusing a slot below.
    set_used(used() - 1);
    idx = empty_idx;
  }
 
  ASSERT(!IsValidEntryAtExclusive(idx));
  // Set the key and value.
  SetObjectAt(idx, key);
  SetValueAt(idx, val);
  // Update the counts.
  set_used(used() + 1);
  set_count(count() + 1);
 
  // Rehash if needed to ensure that there are empty slots available.
  if (used_ >= limit()) {
    Rehash();
  }
}

SetValueIfNonExistent()

intptr_t dart::WeakTable::SetValueIfNonExistent ( ObjectPtr  key, intptr_t  val  )

inline

Definition at line 65 of file weak_table.h.

                                                              {
    MutexLocker ml(&mutex_);
    const auto old_value = GetValueExclusive(key);
    if (old_value == kNoValue) {
      SetValueExclusive(key, val);
      return val;
    }
    return old_value;
  }

size()

intptr_t dart::WeakTable::size ( ) const

inline

Definition at line 49 of file weak_table.h.

{ return size_; }

used()

intptr_t dart::WeakTable::used ( ) const

inline

Definition at line 50 of file weak_table.h.

{ return used_; }

ValueAtExclusive()

intptr_t dart::WeakTable::ValueAtExclusive ( intptr_t  i ) const

inline

Definition at line 100 of file weak_table.h.

                                              {
    ASSERT(i >= 0);
    ASSERT(i < size());
    return data_[ValueIndex(i)];
  }

Member Data Documentation

kNoValue

constexpr intptr_t dart::WeakTable::kNoValue = 0

staticconstexpr

Definition at line 18 of file weak_table.h.

---

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

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