dart::TypeArguments::Cache Class Reference

#include <object.h>

Inheritance diagram for dart::TypeArguments::Cache:

Classes
struct	KeyLocation

Public Types
enum	Header { kMetadataIndex = 0 , kHeaderSize }
enum	Entry {   kSentinelIndex = 0 , kInstantiatorTypeArgsIndex = kSentinelIndex , kFunctionTypeArgsIndex , kInstantiatedTypeArgsIndex ,   kEntrySize }
using	NumOccupiedBits = BitField< intptr_t, intptr_t, 0, compiler::target::kSmiBits - compiler::target::kBitsPerWordLog2 >
using	EntryCountLog2Bits = BitField< intptr_t, intptr_t, NumOccupiedBits::kNextBit, compiler::target::kBitsPerWordLog2 >

Public Member Functions
	Cache (Zone *zone, const TypeArguments &source)
	Cache (Zone *zone, const Array &array)
intptr_t	NumOccupied () const
KeyLocation	FindKeyOrUnused (const TypeArguments &instantiator_tav, const TypeArguments &function_tav) const
bool	IsOccupied (intptr_t entry) const
TypeArgumentsPtr	Retrieve (intptr_t entry) const
KeyLocation	AddEntry (intptr_t entry, const TypeArguments &instantiator_tav, const TypeArguments &function_tav, const TypeArguments &instantiated_tav) const
bool	IsLinear () const
bool	IsHash () const
intptr_t	NumEntries () const
Public Member Functions inherited from dart::ValueObject
	ValueObject ()
	~ValueObject ()

Static Public Member Functions
static SmiPtr	Sentinel ()
static const Array &	EmptyStorage ()

Static Public Attributes
static constexpr intptr_t	kMaxLinearCacheEntries = 10
static constexpr intptr_t	kMaxLinearCacheSize

Friends
class	TypeArguments

Detailed Description

Definition at line 8789 of file object.h.

Member Typedef Documentation

EntryCountLog2Bits

using dart::TypeArguments::Cache::EntryCountLog2Bits = BitField<intptr_t, intptr_t, NumOccupiedBits::kNextBit, compiler::target::kBitsPerWordLog2>

Definition at line 8824 of file object.h.

NumOccupiedBits

using dart::TypeArguments::Cache::NumOccupiedBits = BitField<intptr_t, intptr_t, 0, compiler::target::kSmiBits - compiler::target::kBitsPerWordLog2>

Definition at line 8819 of file object.h.

Member Enumeration Documentation

Entry

enum dart::TypeArguments::Cache::Entry

Enumerator
kSentinelIndex
kInstantiatorTypeArgsIndex
kFunctionTypeArgsIndex
kInstantiatedTypeArgsIndex
kEntrySize

Definition at line 8833 of file object.h.

               {
      kSentinelIndex = 0,  // Used when only checking for sentinel values.
      kInstantiatorTypeArgsIndex = kSentinelIndex,
      kFunctionTypeArgsIndex,
      kInstantiatedTypeArgsIndex,
      kEntrySize,
    };

Header

enum dart::TypeArguments::Cache::Header

Enumerator
kMetadataIndex
kHeaderSize

Definition at line 8805 of file object.h.

                {
      // A single Smi that is a bitfield containing two values:
      // - The number of occupied entries in the cache for all caches.
      // - For hash-based caches, the upper bits contain log2(N) where N
      //   is the number of total entries in the cache, so this information can
      //   be quickly retrieved by stubs.
      //
      // Note: accesses outside of the type arguments canonicalization mutex
      // must have acquire semantics. In C++ code, use NumOccupied to retrieve
      // the number of occupied entries.
      kMetadataIndex = 0,
      kHeaderSize,
    };

Constructor & Destructor Documentation

Cache() [1/2]

dart::TypeArguments::Cache::Cache	(	Zone *	zone,
		const TypeArguments &	source
	)

Definition at line 6977 of file object.cc.

    : zone_(ASSERT_NOTNULL(zone)),
      cache_container_(&source),
      data_(Array::Handle(source.instantiations())),
      smi_handle_(Smi::Handle(zone)) {
  ASSERT(IsolateGroup::Current()
             ->type_arguments_canonicalization_mutex()
             ->IsOwnedByCurrentThread());
}

Cache() [2/2]

dart::TypeArguments::Cache::Cache	(	Zone *	zone,
		const Array &	array
	)

Definition at line 6987 of file object.cc.

    : zone_(ASSERT_NOTNULL(zone)),
      cache_container_(nullptr),
      data_(Array::Handle(array.ptr())),
      smi_handle_(Smi::Handle(zone)) {
  ASSERT(IsolateGroup::Current()
             ->type_arguments_canonicalization_mutex()
             ->IsOwnedByCurrentThread());
}

Member Function Documentation

AddEntry()

TypeArguments::Cache::KeyLocation dart::TypeArguments::Cache::AddEntry	(	intptr_t	entry,
		const TypeArguments &	instantiator_tav,
		const TypeArguments &	function_tav,
		const TypeArguments &	instantiated_tav
	)		const

Definition at line 7114 of file object.cc.

                                                 {
  // We don't do mutating operations in tests without a TypeArguments object.
  ASSERT(cache_container_ != nullptr);
#if defined(DEBUG)
  auto loc = FindKeyOrUnused(instantiator_tav, function_tav);
  ASSERT_EQUAL(loc.entry, entry);
  ASSERT(!loc.present);
#endif
  // Double-check we got the expected entry index when adding to a linear array.
  ASSERT(!IsLinear() || entry == NumOccupied());
  const intptr_t new_occupied = NumOccupied() + 1;
  const bool storage_changed = EnsureCapacity(new_occupied);
  // Note that this call to IsLinear() may return a different result than the
  // earlier, since EnsureCapacity() may have swapped to hash-based storage.
  if (storage_changed && !IsLinear()) {
    // The capacity of the array has changed, and the capacity is used when
    // probing further into the array due to collisions. Thus, we need to redo
    // the entry index calculation.
    auto loc = FindKeyOrUnused(instantiator_tav, function_tav);
    ASSERT(!loc.present);
    entry = loc.entry;
  }
 
  // Go ahead and increment the number of occupied entries prior to adding the
  // entry. Use a store-release barrier in case of concurrent readers.
  const intptr_t metadata = RawSmiValue(Smi::RawCast(data_.At(kMetadataIndex)));
  smi_handle_ = Smi::New(NumOccupiedBits::update(new_occupied, metadata));
  data_.SetAtRelease(kMetadataIndex, smi_handle_);
 
  InstantiationsCacheTable table(data_);
  const auto& tuple = table.At(entry);
  // The parts of the tuple that aren't used for sentinel checking are only
  // retrieved if the entry is occupied. Entries in the cache are never deleted,
  // so once the entry is marked as occupied, the contents of that entry never
  // change. Thus, we don't need store-release barriers here.
  tuple.Set<kFunctionTypeArgsIndex>(function_tav);
  tuple.Set<kInstantiatedTypeArgsIndex>(instantiated_tav);
  // For the sentinel position, though, we do.
  static_assert(
      kSentinelIndex == kInstantiatorTypeArgsIndex,
      "the sentinel position is not protected with a store-release barrier");
  tuple.Set<kInstantiatorTypeArgsIndex, std::memory_order_release>(
      instantiator_tav);
 
  if (storage_changed) {
    // Only check for validity on growth, just to keep the overhead on DEBUG
    // builds down.
    DEBUG_ASSERT(IsValidStorageLocked(data_));
    // Update the container of the original cache to point to the new one.
    cache_container_->set_instantiations(data_);
  }
 
  return {entry, true};
}

EmptyStorage()

static const Array & dart::TypeArguments::Cache::EmptyStorage ( )

inlinestatic

Definition at line 8891 of file object.h.

                                       {
      return Object::empty_instantiations_cache_array();
    }

FindKeyOrUnused()

KeyLocation dart::TypeArguments::Cache::FindKeyOrUnused ( const TypeArguments &  instantiator_tav, const TypeArguments &  function_tav  ) const

inline

Definition at line 8865 of file object.h.

                                                                         {
      return FindKeyOrUnused(data_, instantiator_tav, function_tav);
    }

IsHash()

bool dart::TypeArguments::Cache::IsHash ( ) const

inline

Definition at line 8899 of file object.h.

{ return IsHash(data_); }

IsLinear()

bool dart::TypeArguments::Cache::IsLinear ( ) const

inline

Definition at line 8896 of file object.h.

{ return IsLinear(data_); }

IsOccupied()

bool dart::TypeArguments::Cache::IsOccupied

(

intptr_t

entry

)

const

Definition at line 7056 of file object.cc.

                                                        {
  InstantiationsCacheTable table(data_);
  ASSERT(entry >= 0 && entry < table.Length());
  return table.At(entry).Get<kSentinelIndex>() != Sentinel();
}

NumEntries()

intptr_t dart::TypeArguments::Cache::NumEntries ( ) const

inline

Definition at line 8925 of file object.h.

{ return NumEntries(data_); }

NumOccupied()

intptr_t dart::TypeArguments::Cache::NumOccupied ( ) const

inline

Definition at line 8853 of file object.h.

{ return NumOccupied(data_); }

Retrieve()

TypeArgumentsPtr dart::TypeArguments::Cache::Retrieve

(

intptr_t

entry

)

const

Definition at line 7062 of file object.cc.

                                                                  {
  ASSERT(IsOccupied(entry));
  InstantiationsCacheTable table(data_);
  return table.At(entry).Get<kInstantiatedTypeArgsIndex>();
}

Sentinel()

SmiPtr dart::TypeArguments::Cache::Sentinel ( )

static

Definition at line 7173 of file object.cc.

                                    {
  return Smi::New(kSentinelValue);
}

Friends And Related Function Documentation

TypeArguments

friend class TypeArguments

friend

Definition at line 8975 of file object.h.

Member Data Documentation

kMaxLinearCacheEntries

constexpr intptr_t dart::TypeArguments::Cache::kMaxLinearCacheEntries = 10

staticconstexpr

Definition at line 8933 of file object.h.

kMaxLinearCacheSize

constexpr intptr_t dart::TypeArguments::Cache::kMaxLinearCacheSize

staticconstexpr

Initial value:

=
        kHeaderSize + (kMaxLinearCacheEntries + 1) * kEntrySize

Definition at line 8956 of file object.h.

---

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

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