#include <heap.h>

Public Types
enum	Space { kNew , kOld , kCode }

enum	WeakSelector { kPeers = 0 , kIdentityHashes , kCanonicalHashes , kObjectIds , kLoadingUnits , kHeapSamplingData , kNumWeakSelectors }

Public Member Functions
	~Heap ()

Scavenger *	new_space ()

PageSpace *	old_space ()

uword	Allocate (Thread *thread, intptr_t size, Space space)

bool	AllocatedExternal (intptr_t size, Space space)

void	FreedExternal (intptr_t size, Space space)

void	PromotedExternal (intptr_t size)

void	CheckExternalGC (Thread *thread)

bool	Contains (uword addr) const

bool	NewContains (uword addr) const

bool	OldContains (uword addr) const

bool	CodeContains (uword addr) const

bool	DataContains (uword addr) const

void	NotifyIdle (int64_t deadline)

void	NotifyDestroyed ()

Dart_PerformanceMode	mode () const

Dart_PerformanceMode	SetMode (Dart_PerformanceMode mode)

void	CollectGarbage (Thread *thread, GCType type, GCReason reason)

void	CollectAllGarbage (GCReason reason=GCReason::kFull, bool compact=false)

void	CheckCatchUp (Thread *thread)

void	CheckConcurrentMarking (Thread *thread, GCReason reason, intptr_t size)

void	CheckFinalizeMarking (Thread *thread)

void	StartConcurrentMarking (Thread *thread, GCReason reason)

void	WaitForMarkerTasks (Thread *thread)

void	WaitForSweeperTasks (Thread *thread)

void	WaitForSweeperTasksAtSafepoint (Thread *thread)

void	WriteProtect (bool read_only)

void	WriteProtectCode (bool read_only)

bool	Verify (const char *msg, MarkExpectation mark_expectation=kForbidMarked)

void	PrintSizes () const

intptr_t	UsedInWords (Space space) const

intptr_t	CapacityInWords (Space space) const

intptr_t	ExternalInWords (Space space) const

intptr_t	TotalUsedInWords () const

intptr_t	TotalCapacityInWords () const

intptr_t	TotalExternalInWords () const

int64_t	GCTimeInMicros (Space space) const

intptr_t	Collections (Space space) const

ObjectSet *	CreateAllocatedObjectSet (Zone *zone, MarkExpectation mark_expectation)

void	SetPeer (ObjectPtr raw_obj, void *peer)

void *	GetPeer (ObjectPtr raw_obj) const

int64_t	PeerCount () const

intptr_t	SetHashIfNotSet (ObjectPtr raw_obj, intptr_t hash)

intptr_t	GetHash (ObjectPtr raw_obj) const

void	SetCanonicalHash (ObjectPtr raw_obj, intptr_t hash)

intptr_t	GetCanonicalHash (ObjectPtr raw_obj) const

void	ResetCanonicalHashTable ()

void	SetObjectId (ObjectPtr raw_obj, intptr_t object_id)

intptr_t	GetObjectId (ObjectPtr raw_obj) const

void	ResetObjectIdTable ()

void	SetLoadingUnit (ObjectPtr raw_obj, intptr_t unit_id)

intptr_t	GetLoadingUnit (ObjectPtr raw_obj) const

void	SetHeapSamplingData (ObjectPtr obj, void *data)

intptr_t	GetWeakEntry (ObjectPtr raw_obj, WeakSelector sel) const

void	SetWeakEntry (ObjectPtr raw_obj, WeakSelector sel, intptr_t val)

intptr_t	SetWeakEntryIfNonExistent (ObjectPtr raw_obj, WeakSelector sel, intptr_t val)

WeakTable *	GetWeakTable (Space space, WeakSelector selector) const

void	SetWeakTable (Space space, WeakSelector selector, WeakTable *value)

void	ForwardWeakEntries (ObjectPtr before_object, ObjectPtr after_object)

void	ForwardWeakTables (ObjectPointerVisitor *visitor)

void	ReportSurvivingAllocations (Dart_HeapSamplingReportCallback callback, void *context)

void	UpdateGlobalMaxUsed ()

void	PrintToJSONObject (Space space, JSONObject *object) const

void	PrintMemoryUsageJSON (JSONStream *stream) const

void	PrintMemoryUsageJSON (JSONObject *jsobj) const

void	PrintHeapMapToJSONStream (IsolateGroup isolate_group, JSONStream stream)

intptr_t	ReachabilityBarrier ()

IsolateGroup *	isolate_group () const

bool	is_vm_isolate () const

void	SetupImagePage (void *pointer, uword size, bool is_executable)

Space	SpaceForExternal (intptr_t size) const

void	CollectOnNthAllocation (intptr_t num_allocations)

Static Public Member Functions
static void	Init (IsolateGroup *isolate_group, bool is_vm_isolate, intptr_t max_new_gen_words, intptr_t max_old_gen_words)

static const char *	GCTypeToString (GCType type)

static const char *	GCReasonToString (GCReason reason)

Static Public Attributes
static constexpr uint8_t	kZapByte = 0xf3

Friends
class	Become

class	GCCompactor

class	Precompiler

class	ServiceEvent

class	Scavenger

class	PageSpace

class	ProgramReloadContext

class	ClassFinalizer

class	HeapIterationScope

class	GCMarker

class	ProgramVisitor

class	Serializer

class	HeapTestHelper

class	GCTestHelper

Detailed Description

Definition at line 35 of file heap.h.

Member Enumeration Documentation

◆ Space

enum dart::Heap::Space

Enumerator
kNew
kOld
kCode

Definition at line 37 of file heap.h.

             {
    kNew,
    kOld,
    kCode,
  };

◆ WeakSelector

enum dart::Heap::WeakSelector

Enumerator
kPeers
kIdentityHashes
kCanonicalHashes
kObjectIds
kLoadingUnits
kHeapSamplingData
kNumWeakSelectors

Definition at line 43 of file heap.h.

                    {
    kPeers = 0,
#if !defined(HASH_IN_OBJECT_HEADER)
    kIdentityHashes,
#endif
    kCanonicalHashes,
    kObjectIds,
    kLoadingUnits,
#if !defined(PRODUCT) || defined(FORCE_INCLUDE_SAMPLING_HEAP_PROFILER)
    kHeapSamplingData,
#endif
    kNumWeakSelectors
  };

Constructor & Destructor Documentation

◆ ~Heap()

dart::Heap::~Heap ( )

Definition at line 62 of file heap.cc.

            {
#if !defined(PRODUCT) || defined(FORCE_INCLUDE_SAMPLING_HEAP_PROFILER)
  Dart_HeapSamplingDeleteCallback cleanup =
      HeapProfileSampler::delete_callback();
  if (cleanup != nullptr) {
    new_weak_tables_[kHeapSamplingData]->CleanupValues(cleanup);
    old_weak_tables_[kHeapSamplingData]->CleanupValues(cleanup);
  }
#endif
 
  for (int sel = 0; sel < kNumWeakSelectors; sel++) {
    delete new_weak_tables_[sel];
    delete old_weak_tables_[sel];
  }
}

Member Function Documentation

◆ Allocate()

uword dart::Heap::Allocate	(	Thread *	thread,
		intptr_t	size,
		Space	space
	)

inline

Definition at line 65 of file heap.h.

                                                             {
    ASSERT(!read_only_);
    switch (space) {
      case kNew:
        // Do not attempt to allocate very large objects in new space.
        if (!IsAllocatableInNewSpace(size)) {
          return AllocateOld(thread, size, /*executable*/ false);
        }
        return AllocateNew(thread, size);
      case kOld:
        return AllocateOld(thread, size, /*executable*/ false);
      case kCode:
        return AllocateOld(thread, size, /*executable*/ true);
      default:
        UNREACHABLE();
    }
    return 0;
  }

◆ AllocatedExternal()

bool dart::Heap::AllocatedExternal	(	intptr_t	size,
		Space	space
	)

Definition at line 179 of file heap.cc.

                                                       {
  if (space == kNew) {
    if (!new_space_.AllocatedExternal(size)) {
      return false;
    }
  } else {
    ASSERT(space == kOld);
    if (!old_space_.AllocatedExternal(size)) {
      return false;
    }
  }
 
  Thread* thread = Thread::Current();
  if ((thread->no_callback_scope_depth() == 0) && !thread->force_growth()) {
    CheckExternalGC(thread);
  } else {
    // Check delayed until Dart_TypedDataRelease/~ForceGrowthScope.
  }
  return true;
}

◆ CapacityInWords()

intptr_t dart::Heap::CapacityInWords ( Space space ) const

Definition at line 795 of file heap.cc.

                                                {
  return space == kNew ? new_space_.CapacityInWords()
                       : old_space_.CapacityInWords();
}

◆ CheckCatchUp()

void dart::Heap::CheckCatchUp ( Thread * thread )

Definition at line 574 of file heap.cc.

                                      {
  ASSERT(!thread->force_growth());
  if (old_space()->ReachedHardThreshold()) {
    CollectGarbage(thread, GCType::kMarkSweep, GCReason::kCatchUp);
  } else {
    CheckConcurrentMarking(thread, GCReason::kCatchUp, 0);
  }
}

◆ CheckConcurrentMarking()

void dart::Heap::CheckConcurrentMarking	(	Thread *	thread,
		GCReason	reason,
		intptr_t	size
	)

Definition at line 583 of file heap.cc.

                                                 {
  ASSERT(!thread->force_growth());
 
  PageSpace::Phase phase;
  {
    MonitorLocker ml(old_space_.tasks_lock());
    phase = old_space_.phase();
  }
 
  switch (phase) {
    case PageSpace::kMarking:
      if (mode_ != Dart_PerformanceMode_Latency) {
        old_space_.IncrementalMarkWithSizeBudget(size);
      }
      return;
    case PageSpace::kSweepingLarge:
    case PageSpace::kSweepingRegular:
      return;  // Busy.
    case PageSpace::kAwaitingFinalization:
      CollectOldSpaceGarbage(thread, GCType::kMarkSweep, GCReason::kFinalize);
      return;
    case PageSpace::kDone:
      if (old_space_.ReachedSoftThreshold()) {
        StartConcurrentMarking(thread, reason);
      }
      return;
    default:
      UNREACHABLE();
  }
}

◆ CheckExternalGC()

void dart::Heap::CheckExternalGC ( Thread * thread )

Definition at line 214 of file heap.cc.

                                         {
  ASSERT(thread->no_safepoint_scope_depth() == 0);
  ASSERT(thread->no_callback_scope_depth() == 0);
  ASSERT(!thread->force_growth());
 
  if (mode_ == Dart_PerformanceMode_Latency) {
    return;
  }
 
  if (new_space_.ExternalInWords() >= (4 * new_space_.CapacityInWords())) {
    // Attempt to free some external allocation by a scavenge. (If the total
    // remains above the limit, next external alloc will trigger another.)
    CollectGarbage(thread, GCType::kScavenge, GCReason::kExternal);
    // Promotion may have pushed old space over its limit. Fall through for old
    // space GC check.
  }
 
  if (old_space_.ReachedHardThreshold()) {
    CollectGarbage(thread, GCType::kMarkSweep, GCReason::kExternal);
  } else {
    CheckConcurrentMarking(thread, GCReason::kExternal, 0);
  }
}

◆ CheckFinalizeMarking()

void dart::Heap::CheckFinalizeMarking ( Thread * thread )

Definition at line 616 of file heap.cc.

                                              {
  ASSERT(!thread->force_growth());
 
  PageSpace::Phase phase;
  {
    MonitorLocker ml(old_space_.tasks_lock());
    phase = old_space_.phase();
  }
 
  if (phase == PageSpace::kAwaitingFinalization) {
    CollectOldSpaceGarbage(thread, GCType::kMarkSweep, GCReason::kFinalize);
  }
}

◆ CodeContains()

bool dart::Heap::CodeContains ( uword addr ) const

Definition at line 250 of file heap.cc.

                                        {
  return old_space_.CodeContains(addr);
}

◆ CollectAllGarbage()

void dart::Heap::CollectAllGarbage	(	GCReason	reason = `GCReason::kFull`,
		bool	compact = `false`
	)

Definition at line 562 of file heap.cc.

                                                          {
  Thread* thread = Thread::Current();
  if (thread->is_marking()) {
    // If incremental marking is happening, we need to finish the GC cycle
    // and perform a follow-up GC to purge any "floating garbage" that may be
    // retained by the incremental barrier.
    CollectOldSpaceGarbage(thread, GCType::kMarkSweep, reason);
  }
  CollectOldSpaceGarbage(
      thread, compact ? GCType::kMarkCompact : GCType::kMarkSweep, reason);
}

◆ CollectGarbage()

void dart::Heap::CollectGarbage	(	Thread *	thread,
		GCType	type,
		GCReason	reason
	)

Definition at line 547 of file heap.cc.

                                                                      {
  switch (type) {
    case GCType::kScavenge:
    case GCType::kEvacuate:
      CollectNewSpaceGarbage(thread, type, reason);
      break;
    case GCType::kMarkSweep:
    case GCType::kMarkCompact:
      CollectOldSpaceGarbage(thread, type, reason);
      break;
    default:
      UNREACHABLE();
  }
}

◆ Collections()

intptr_t dart::Heap::Collections ( Space space ) const

Definition at line 824 of file heap.cc.

                                            {
  if (space == kNew) {
    return new_space_.collections();
  }
  return old_space_.collections();
}

◆ CollectOnNthAllocation()

void dart::Heap::CollectOnNthAllocation ( intptr_t num_allocations )

Definition at line 709 of file heap.cc.

                                                          {
  // Prevent generated code from using the TLAB fast path on next allocation.
  new_space_.AbandonRemainingTLABForDebugging(Thread::Current());
  gc_on_nth_allocation_ = num_allocations;
}

◆ Contains()

bool dart::Heap::Contains ( uword addr ) const

Definition at line 238 of file heap.cc.

                                    {
  return new_space_.Contains(addr) || old_space_.Contains(addr);
}

◆ CreateAllocatedObjectSet()

ObjectSet * dart::Heap::CreateAllocatedObjectSet	(	Zone *	zone,
		MarkExpectation	mark_expectation
	)

Definition at line 732 of file heap.cc.

                                                                            {
  ObjectSet* allocated_set = new (zone) ObjectSet(zone);
 
  this->AddRegionsToObjectSet(allocated_set);
  Isolate* vm_isolate = Dart::vm_isolate();
  vm_isolate->group()->heap()->AddRegionsToObjectSet(allocated_set);
 
  {
    VerifyObjectVisitor object_visitor(isolate_group(), allocated_set,
                                       mark_expectation);
    this->VisitObjectsNoImagePages(&object_visitor);
  }
  {
    VerifyObjectVisitor object_visitor(isolate_group(), allocated_set,
                                       kRequireMarked);
    this->VisitObjectsImagePages(&object_visitor);
  }
  {
    // VM isolate heap is premarked.
    VerifyObjectVisitor vm_object_visitor(isolate_group(), allocated_set,
                                          kRequireMarked);
    vm_isolate->group()->heap()->VisitObjects(&vm_object_visitor);
  }
 
  return allocated_set;
}

◆ DataContains()

bool dart::Heap::DataContains ( uword addr ) const

Definition at line 254 of file heap.cc.

                                        {
  return old_space_.DataContains(addr);
}

◆ ExternalInWords()

intptr_t dart::Heap::ExternalInWords ( Space space ) const

Definition at line 800 of file heap.cc.

                                                {
  return space == kNew ? new_space_.ExternalInWords()
                       : old_space_.ExternalInWords();
}

◆ ForwardWeakEntries()

void dart::Heap::ForwardWeakEntries	(	ObjectPtr	before_object,
		ObjectPtr	after_object
	)

Definition at line 919 of file heap.cc.

                                                                             {
  const auto before_space =
      before_object->IsImmediateOrOldObject() ? Heap::kOld : Heap::kNew;
  const auto after_space =
      after_object->IsImmediateOrOldObject() ? Heap::kOld : Heap::kNew;
 
  for (int sel = 0; sel < Heap::kNumWeakSelectors; sel++) {
    const auto selector = static_cast<Heap::WeakSelector>(sel);
    auto before_table = GetWeakTable(before_space, selector);
    intptr_t entry = before_table->RemoveValueExclusive(before_object);
    if (entry != 0) {
      auto after_table = GetWeakTable(after_space, selector);
      after_table->SetValueExclusive(after_object, entry);
    }
  }
 
  isolate_group()->ForEachIsolate(
      [&](Isolate* isolate) {
        auto before_table = before_object->IsImmediateOrOldObject()
                                ? isolate->forward_table_old()
                                : isolate->forward_table_new();
        if (before_table != nullptr) {
          intptr_t entry = before_table->RemoveValueExclusive(before_object);
          if (entry != 0) {
            auto after_table = after_object->IsImmediateOrOldObject()
                                   ? isolate->forward_table_old()
                                   : isolate->forward_table_new();
            ASSERT(after_table != nullptr);
            after_table->SetValueExclusive(after_object, entry);
          }
        }
      },
      /*at_safepoint=*/true);
}

◆ ForwardWeakTables()

void dart::Heap::ForwardWeakTables ( ObjectPointerVisitor * visitor )

Definition at line 954 of file heap.cc.

                                                          {
  // NOTE: This method is only used by the compactor, so there is no need to
  // process the `Heap::kNew` tables.
  for (int sel = 0; sel < Heap::kNumWeakSelectors; sel++) {
    WeakSelector selector = static_cast<Heap::WeakSelector>(sel);
    GetWeakTable(Heap::kOld, selector)->Forward(visitor);
  }
 
  // Isolates might have forwarding tables (used for during snapshotting in
  // isolate communication).
  isolate_group()->ForEachIsolate(
      [&](Isolate* isolate) {
        auto table_old = isolate->forward_table_old();
        if (table_old != nullptr) table_old->Forward(visitor);
      },
      /*at_safepoint=*/true);
}

◆ FreedExternal()

void dart::Heap::FreedExternal	(	intptr_t	size,
		Space	space
	)

Definition at line 200 of file heap.cc.

                                                   {
  if (space == kNew) {
    new_space_.FreedExternal(size);
  } else {
    ASSERT(space == kOld);
    old_space_.FreedExternal(size);
  }
}

◆ GCReasonToString()

const char * dart::Heap::GCReasonToString ( GCReason reason )

static

Definition at line 849 of file heap.cc.

                                                     {
  switch (gc_reason) {
    case GCReason::kNewSpace:
      return "new space";
    case GCReason::kStoreBuffer:
      return "store buffer";
    case GCReason::kPromotion:
      return "promotion";
    case GCReason::kOldSpace:
      return "old space";
    case GCReason::kFinalize:
      return "finalize";
    case GCReason::kFull:
      return "full";
    case GCReason::kExternal:
      return "external";
    case GCReason::kIdle:
      return "idle";
    case GCReason::kDestroyed:
      return "destroyed";
    case GCReason::kDebugging:
      return "debugging";
    case GCReason::kCatchUp:
      return "catch-up";
    default:
      UNREACHABLE();
      return "";
  }
}

◆ GCTimeInMicros()

int64_t dart::Heap::GCTimeInMicros ( Space space ) const

Definition at line 817 of file heap.cc.

                                              {
  if (space == kNew) {
    return new_space_.gc_time_micros();
  }
  return old_space_.gc_time_micros();
}

◆ GCTypeToString()

const char * dart::Heap::GCTypeToString ( GCType type )

static

Definition at line 831 of file heap.cc.

                                            {
  switch (type) {
    case GCType::kScavenge:
      return "Scavenge";
    case GCType::kEvacuate:
      return "Evacuate";
    case GCType::kStartConcurrentMark:
      return "StartCMark";
    case GCType::kMarkSweep:
      return "MarkSweep";
    case GCType::kMarkCompact:
      return "MarkCompact";
    default:
      UNREACHABLE();
      return "";
  }
}

◆ GetCanonicalHash()

intptr_t dart::Heap::GetCanonicalHash ( ObjectPtr raw_obj ) const

inline

Definition at line 186 of file heap.h.

                                                     {
    return GetWeakEntry(raw_obj, kCanonicalHashes);
  }

◆ GetHash()

intptr_t dart::Heap::GetHash ( ObjectPtr raw_obj ) const

inline

Definition at line 178 of file heap.h.

                                            {
    return GetWeakEntry(raw_obj, kIdentityHashes);
  }

◆ GetLoadingUnit()

intptr_t dart::Heap::GetLoadingUnit ( ObjectPtr raw_obj ) const

inline

Definition at line 207 of file heap.h.

                                                   {
    ASSERT(Thread::Current()->IsDartMutatorThread());
    return GetWeakEntry(raw_obj, kLoadingUnits);
  }

◆ GetObjectId()

intptr_t dart::Heap::GetObjectId ( ObjectPtr raw_obj ) const

inline

Definition at line 197 of file heap.h.

                                                {
    ASSERT(Thread::Current()->IsDartMutatorThread());
    return GetWeakEntry(raw_obj, kObjectIds);
  }

◆ GetPeer()

void * dart::Heap::GetPeer ( ObjectPtr raw_obj ) const

inline

Definition at line 167 of file heap.h.

                                         {
    return reinterpret_cast<void*>(GetWeakEntry(raw_obj, kPeers));
  }

◆ GetWeakEntry()

intptr_t dart::Heap::GetWeakEntry	(	ObjectPtr	raw_obj,
		WeakSelector	sel
	)		const

Definition at line 893 of file heap.cc.

                                                                     {
  if (raw_obj->IsImmediateOrOldObject()) {
    return old_weak_tables_[sel]->GetValue(raw_obj);
  } else {
    return new_weak_tables_[sel]->GetValue(raw_obj);
  }
}

◆ GetWeakTable()

WeakTable * dart::Heap::GetWeakTable	(	Space	space,
		WeakSelector	selector
	)		const

inline

Definition at line 225 of file heap.h.

                                                                    {
    if (space == kNew) {
      return new_weak_tables_[selector];
    }
    ASSERT(space == kOld);
    return old_weak_tables_[selector];
  }

◆ Init()

void dart::Heap::Init	(	IsolateGroup *	isolate_group,
		bool	is_vm_isolate,
		intptr_t	max_new_gen_words,
		intptr_t	max_old_gen_words
	)

static

Definition at line 693 of file heap.cc.

                                            {
  ASSERT(isolate_group->heap() == nullptr);
  std::unique_ptr<Heap> heap(new Heap(isolate_group, is_vm_isolate,
                                      max_new_gen_words, max_old_gen_words));
  isolate_group->set_heap(std::move(heap));
}

◆ is_vm_isolate()

bool dart::Heap::is_vm_isolate ( ) const

inline

Definition at line 274 of file heap.h.

274{ return is_vm_isolate_; }

◆ isolate_group()

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

inline

Definition at line 273 of file heap.h.

273{ return isolate_group_; }

◆ mode()

Dart_PerformanceMode dart::Heap::mode ( ) const

inline

Definition at line 103 of file heap.h.

103{ return mode_; }

◆ new_space()

Scavenger * dart::Heap::new_space ( )

inline

Definition at line 62 of file heap.h.

62{ return &new_space_; }

◆ NewContains()

bool dart::Heap::NewContains ( uword addr ) const

Definition at line 242 of file heap.cc.

                                       {
  return new_space_.Contains(addr);
}

◆ NotifyDestroyed()

void dart::Heap::NotifyDestroyed ( )

Definition at line 435 of file heap.cc.

                           {
  TIMELINE_FUNCTION_GC_DURATION(Thread::Current(), "NotifyDestroyed");
  CollectAllGarbage(GCReason::kDestroyed, /*compact=*/true);
  Page::ClearCache();
}

◆ NotifyIdle()

void dart::Heap::NotifyIdle ( int64_t deadline )

Definition at line 374 of file heap.cc.

                                      {
  Thread* thread = Thread::Current();
  TIMELINE_FUNCTION_GC_DURATION(thread, "NotifyIdle");
  {
    GcSafepointOperationScope safepoint_operation(thread);
 
    // Check if we want to collect new-space first, because if we want to
    // collect both new-space and old-space, the new-space collection should run
    // first to shrink the root set (make old-space GC faster) and avoid
    // intergenerational garbage (make old-space GC free more memory).
    if (new_space_.ShouldPerformIdleScavenge(deadline)) {
      CollectNewSpaceGarbage(thread, GCType::kScavenge, GCReason::kIdle);
    }
 
    // Check if we want to collect old-space, in decreasing order of cost.
    // Because we use a deadline instead of a timeout, we automatically take any
    // time used up by a scavenge into account when deciding if we can complete
    // a mark-sweep on time.
    if (old_space_.ShouldPerformIdleMarkCompact(deadline)) {
      // We prefer mark-compact over other old space GCs if we have enough time,
      // since it removes old space fragmentation and frees up most memory.
      // Blocks for O(heap), roughly twice as costly as mark-sweep.
      CollectOldSpaceGarbage(thread, GCType::kMarkCompact, GCReason::kIdle);
    } else if (old_space_.ReachedHardThreshold()) {
      // Even though the following GC may exceed our idle deadline, we need to
      // ensure than that promotions during idle scavenges do not lead to
      // unbounded growth of old space. If a program is allocating only in new
      // space and all scavenges happen during idle time, then NotifyIdle will
      // be the only place that checks the old space allocation limit.
      // Compare the tail end of Heap::CollectNewSpaceGarbage.
      // Blocks for O(heap).
      CollectOldSpaceGarbage(thread, GCType::kMarkSweep, GCReason::kIdle);
    } else if (old_space_.ShouldStartIdleMarkSweep(deadline) ||
               old_space_.ReachedSoftThreshold()) {
      // If we have both work to do and enough time, start or finish GC.
      // If we have crossed the soft threshold, ignore time; the next old-space
      // allocation will trigger this work anyway, so we try to pay at least
      // some of that cost with idle time.
      // Blocks for O(roots).
      PageSpace::Phase phase;
      {
        MonitorLocker ml(old_space_.tasks_lock());
        phase = old_space_.phase();
      }
      if (phase == PageSpace::kAwaitingFinalization) {
        CollectOldSpaceGarbage(thread, GCType::kMarkSweep, GCReason::kFinalize);
      } else if (phase == PageSpace::kDone) {
        StartConcurrentMarking(thread, GCReason::kIdle);
      }
    }
  }
 
  if (FLAG_mark_when_idle) {
    old_space_.IncrementalMarkWithTimeBudget(deadline);
  }
 
  if (OS::GetCurrentMonotonicMicros() < deadline) {
    Page::ClearCache();
  }
}

◆ old_space()

PageSpace * dart::Heap::old_space ( )

inline

Definition at line 63 of file heap.h.

63{ return &old_space_; }

◆ OldContains()

bool dart::Heap::OldContains ( uword addr ) const

Definition at line 246 of file heap.cc.

                                       {
  return old_space_.Contains(addr);
}

◆ PeerCount()

int64_t dart::Heap::PeerCount ( ) const

Definition at line 879 of file heap.cc.

                              {
  return new_weak_tables_[kPeers]->count() + old_weak_tables_[kPeers]->count();
}

◆ PrintHeapMapToJSONStream()

void dart::Heap::PrintHeapMapToJSONStream	(	IsolateGroup *	isolate_group,
		JSONStream *	stream
	)

inline

Definition at line 265 of file heap.h.

                                                    {
    old_space_.PrintHeapMapToJSONStream(isolate_group, stream);
  }

◆ PrintMemoryUsageJSON() [1/2]

void dart::Heap::PrintMemoryUsageJSON ( JSONObject * jsobj ) const

Definition at line 986 of file heap.cc.

                                                       {
  jsobj->AddProperty("type", "MemoryUsage");
  jsobj->AddProperty64("heapUsage", TotalUsedInWords() * kWordSize);
  jsobj->AddProperty64("heapCapacity", TotalCapacityInWords() * kWordSize);
  jsobj->AddProperty64("externalUsage", TotalExternalInWords() * kWordSize);
}

◆ PrintMemoryUsageJSON() [2/2]

void dart::Heap::PrintMemoryUsageJSON ( JSONStream * stream ) const

Definition at line 981 of file heap.cc.

                                                        {
  JSONObject obj(stream);
  PrintMemoryUsageJSON(&obj);
}

◆ PrintSizes()

void dart::Heap::PrintSizes ( ) const

Definition at line 782 of file heap.cc.

                            {
  OS::PrintErr(
      "New space (%" Pd "k of %" Pd
      "k) "
      "Old space (%" Pd "k of %" Pd "k)\n",
      (UsedInWords(kNew) / KBInWords), (CapacityInWords(kNew) / KBInWords),
      (UsedInWords(kOld) / KBInWords), (CapacityInWords(kOld) / KBInWords));
}

◆ PrintToJSONObject()

void dart::Heap::PrintToJSONObject	(	Space	space,
		JSONObject *	object
	)		const

Definition at line 973 of file heap.cc.

                                                                  {
  if (space == kNew) {
    new_space_.PrintToJSONObject(object);
  } else {
    old_space_.PrintToJSONObject(object);
  }
}

◆ PromotedExternal()

void dart::Heap::PromotedExternal ( intptr_t size )

Definition at line 209 of file heap.cc.

                                         {
  new_space_.FreedExternal(size);
  old_space_.AllocatedExternal(size);
}

◆ ReachabilityBarrier()

intptr_t dart::Heap::ReachabilityBarrier ( )

inline

Definition at line 271 of file heap.h.

271{ return old_space_.collections(); }

◆ ReportSurvivingAllocations()

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

inline

Definition at line 245 of file heap.h.

                                                 {
    new_weak_tables_[kHeapSamplingData]->ReportSurvivingAllocations(callback,
                                                                    context);
    old_weak_tables_[kHeapSamplingData]->ReportSurvivingAllocations(callback,
                                                                    context);
  }

◆ ResetCanonicalHashTable()

void dart::Heap::ResetCanonicalHashTable ( )

Definition at line 883 of file heap.cc.

                                   {
  new_weak_tables_[kCanonicalHashes]->Reset();
  old_weak_tables_[kCanonicalHashes]->Reset();
}

◆ ResetObjectIdTable()

void dart::Heap::ResetObjectIdTable ( )

Definition at line 888 of file heap.cc.

                              {
  new_weak_tables_[kObjectIds]->Reset();
  old_weak_tables_[kObjectIds]->Reset();
}

◆ SetCanonicalHash()

void dart::Heap::SetCanonicalHash	(	ObjectPtr	raw_obj,
		intptr_t	hash
	)

inline

Definition at line 183 of file heap.h.

                                                          {
    SetWeakEntry(raw_obj, kCanonicalHashes, hash);
  }

◆ SetHashIfNotSet()

intptr_t dart::Heap::SetHashIfNotSet	(	ObjectPtr	raw_obj,
		intptr_t	hash
	)

inline

Definition at line 175 of file heap.h.

                                                             {
    return SetWeakEntryIfNonExistent(raw_obj, kIdentityHashes, hash);
  }

◆ SetHeapSamplingData()

void dart::Heap::SetHeapSamplingData	(	ObjectPtr	obj,
		void *	data
	)

inline

Definition at line 213 of file heap.h.

                                                      {
    SetWeakEntry(obj, kHeapSamplingData, reinterpret_cast<intptr_t>(data));
  }

◆ SetLoadingUnit()

void dart::Heap::SetLoadingUnit	(	ObjectPtr	raw_obj,
		intptr_t	unit_id
	)

inline

Definition at line 203 of file heap.h.

                                                           {
    ASSERT(Thread::Current()->IsDartMutatorThread());
    SetWeakEntry(raw_obj, kLoadingUnits, unit_id);
  }

◆ SetMode()

Dart_PerformanceMode dart::Heap::SetMode ( Dart_PerformanceMode mode )

Definition at line 441 of file heap.cc.

                                                                {
  Dart_PerformanceMode old_mode = mode_.exchange(new_mode);
  if ((old_mode == Dart_PerformanceMode_Latency) &&
      (new_mode == Dart_PerformanceMode_Default)) {
    CheckCatchUp(Thread::Current());
  }
  return old_mode;
}

◆ SetObjectId()

void dart::Heap::SetObjectId	(	ObjectPtr	raw_obj,
		intptr_t	object_id
	)

inline

Definition at line 193 of file heap.h.

                                                          {
    ASSERT(Thread::Current()->IsDartMutatorThread());
    SetWeakEntry(raw_obj, kObjectIds, object_id);
  }

◆ SetPeer()

void dart::Heap::SetPeer	(	ObjectPtr	raw_obj,
		void *	peer
	)

inline

Definition at line 164 of file heap.h.

                                              {
    SetWeakEntry(raw_obj, kPeers, reinterpret_cast<intptr_t>(peer));
  }

◆ SetupImagePage()

void dart::Heap::SetupImagePage	(	void *	pointer,
		uword	size,
		bool	is_executable
	)

inline

Definition at line 276 of file heap.h.

                                                                     {
    old_space_.SetupImagePage(pointer, size, is_executable);
  }

◆ SetWeakEntry()

void dart::Heap::SetWeakEntry	(	ObjectPtr	raw_obj,
		WeakSelector	sel,
		intptr_t	val
	)

Definition at line 901 of file heap.cc.

                                                                         {
  if (raw_obj->IsImmediateOrOldObject()) {
    old_weak_tables_[sel]->SetValue(raw_obj, val);
  } else {
    new_weak_tables_[sel]->SetValue(raw_obj, val);
  }
}

◆ SetWeakEntryIfNonExistent()

intptr_t dart::Heap::SetWeakEntryIfNonExistent	(	ObjectPtr	raw_obj,
		WeakSelector	sel,
		intptr_t	val
	)

Definition at line 909 of file heap.cc.

                                                       {
  if (raw_obj->IsImmediateOrOldObject()) {
    return old_weak_tables_[sel]->SetValueIfNonExistent(raw_obj, val);
  } else {
    return new_weak_tables_[sel]->SetValueIfNonExistent(raw_obj, val);
  }
}

◆ SetWeakTable()

void dart::Heap::SetWeakTable	(	Space	space,
		WeakSelector	selector,
		WeakTable *	value
	)

inline

Definition at line 232 of file heap.h.

                                                                          {
    if (space == kNew) {
      new_weak_tables_[selector] = value;
    } else {
      ASSERT(space == kOld);
      old_weak_tables_[selector] = value;
    }
  }

◆ SpaceForExternal()

Heap::Space dart::Heap::SpaceForExternal ( intptr_t size ) const

Definition at line 1130 of file heap.cc.

                                                    {
  // If 'size' would be a significant fraction of new space, then use old.
  const int kExtNewRatio = 16;
  if (size > (new_space_.ThresholdInWords() * kWordSize) / kExtNewRatio) {
    return Heap::kOld;
  } else {
    return Heap::kNew;
  }
}

◆ StartConcurrentMarking()

void dart::Heap::StartConcurrentMarking	(	Thread *	thread,
		GCReason	reason
	)

Definition at line 630 of file heap.cc.

                                                                 {
  GcSafepointOperationScope safepoint_operation(thread);
  RecordBeforeGC(GCType::kStartConcurrentMark, reason);
  VMTagScope tagScope(thread, reason == GCReason::kIdle
                                  ? VMTag::kGCIdleTagId
                                  : VMTag::kGCOldSpaceTagId);
  TIMELINE_FUNCTION_GC_DURATION(thread, "StartConcurrentMarking");
  old_space_.CollectGarbage(thread, /*compact=*/false, /*finalize=*/false);
  RecordAfterGC(GCType::kStartConcurrentMark);
  PrintStats();
#if defined(SUPPORT_TIMELINE)
  PrintStatsToTimeline(&tbes, reason);
#endif
}

◆ TotalCapacityInWords()

intptr_t dart::Heap::TotalCapacityInWords ( ) const

Definition at line 809 of file heap.cc.

                                          {
  return CapacityInWords(kNew) + CapacityInWords(kOld);
}

◆ TotalExternalInWords()

intptr_t dart::Heap::TotalExternalInWords ( ) const

Definition at line 813 of file heap.cc.

                                          {
  return ExternalInWords(kNew) + ExternalInWords(kOld);
}

◆ TotalUsedInWords()

intptr_t dart::Heap::TotalUsedInWords ( ) const

Definition at line 805 of file heap.cc.

                                      {
  return UsedInWords(kNew) + UsedInWords(kOld);
}

◆ UpdateGlobalMaxUsed()

void dart::Heap::UpdateGlobalMaxUsed ( )

Definition at line 678 of file heap.cc.

                               {
  ASSERT(isolate_group_ != nullptr);
  // We are accessing the used in words count for both new and old space
  // without synchronizing. The value of this metric is approximate.
  isolate_group_->GetHeapGlobalUsedMaxMetric()->SetValue(
      (UsedInWords(Heap::kNew) * kWordSize) +
      (UsedInWords(Heap::kOld) * kWordSize));
}

◆ UsedInWords()

intptr_t dart::Heap::UsedInWords ( Space space ) const

Definition at line 791 of file heap.cc.

                                            {
  return space == kNew ? new_space_.UsedInWords() : old_space_.UsedInWords();
}

◆ Verify()

bool dart::Heap::Verify	(	const char *	msg,
		MarkExpectation	mark_expectation = `kForbidMarked`
	)

Definition at line 760 of file heap.cc.

                                                                   {
  if (FLAG_disable_heap_verification) {
    return true;
  }
  HeapIterationScope heap_iteration_scope(Thread::Current());
  return VerifyGC(msg, mark_expectation);
}

◆ WaitForMarkerTasks()

void dart::Heap::WaitForMarkerTasks ( Thread * thread )

Definition at line 645 of file heap.cc.

                                            {
  MonitorLocker ml(old_space_.tasks_lock());
  while ((old_space_.phase() == PageSpace::kMarking) ||
         (old_space_.phase() == PageSpace::kAwaitingFinalization)) {
    while (old_space_.phase() == PageSpace::kMarking) {
      ml.WaitWithSafepointCheck(thread);
    }
    if (old_space_.phase() == PageSpace::kAwaitingFinalization) {
      ml.Exit();
      CollectOldSpaceGarbage(thread, GCType::kMarkSweep, GCReason::kFinalize);
      ml.Enter();
    }
  }
}

◆ WaitForSweeperTasks()

void dart::Heap::WaitForSweeperTasks ( Thread * thread )

Definition at line 660 of file heap.cc.

                                             {
  ASSERT(!thread->OwnsGCSafepoint());
  MonitorLocker ml(old_space_.tasks_lock());
  while ((old_space_.phase() == PageSpace::kSweepingLarge) ||
         (old_space_.phase() == PageSpace::kSweepingRegular)) {
    ml.WaitWithSafepointCheck(thread);
  }
}

◆ WaitForSweeperTasksAtSafepoint()

void dart::Heap::WaitForSweeperTasksAtSafepoint ( Thread * thread )

Definition at line 669 of file heap.cc.

                                                        {
  ASSERT(thread->OwnsGCSafepoint());
  MonitorLocker ml(old_space_.tasks_lock());
  while ((old_space_.phase() == PageSpace::kSweepingLarge) ||
         (old_space_.phase() == PageSpace::kSweepingRegular)) {
    ml.Wait();
  }
}

◆ WriteProtect()

void dart::Heap::WriteProtect ( bool read_only )

Definition at line 687 of file heap.cc.

                                      {
  read_only_ = read_only;
  new_space_.WriteProtect(read_only);
  old_space_.WriteProtect(read_only);
}

◆ WriteProtectCode()

void dart::Heap::WriteProtectCode ( bool read_only )

inline

Definition at line 127 of file heap.h.

                                        {
    old_space_.WriteProtectCode(read_only);
  }

Friends And Related Symbol Documentation

◆ Become

friend class Become

friend

Definition at line 376 of file heap.h.

◆ ClassFinalizer

friend class ClassFinalizer

friend

Definition at line 383 of file heap.h.

◆ GCCompactor

friend class GCCompactor

friend

Definition at line 377 of file heap.h.

◆ GCMarker

friend class GCMarker

friend

Definition at line 385 of file heap.h.

◆ GCTestHelper

friend class GCTestHelper

friend

Definition at line 389 of file heap.h.

◆ HeapIterationScope

friend class HeapIterationScope

friend

Definition at line 384 of file heap.h.

◆ HeapTestHelper

friend class HeapTestHelper

friend

Definition at line 388 of file heap.h.

◆ PageSpace

friend class PageSpace

friend

Definition at line 381 of file heap.h.

◆ Precompiler

friend class Precompiler

friend

Definition at line 378 of file heap.h.

◆ ProgramReloadContext

friend class ProgramReloadContext

friend

Definition at line 382 of file heap.h.

◆ ProgramVisitor

friend class ProgramVisitor

friend

Definition at line 386 of file heap.h.

◆ Scavenger

friend class Scavenger

friend

Definition at line 380 of file heap.h.

◆ Serializer

friend class Serializer

friend

Definition at line 387 of file heap.h.

◆ ServiceEvent

friend class ServiceEvent

friend

Definition at line 379 of file heap.h.

Member Data Documentation

◆ kZapByte

constexpr uint8_t dart::Heap::kZapByte = 0xf3

staticconstexpr

Definition at line 58 of file heap.h.

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

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

Public Types

Public Member Functions

Static Public Member Functions

Static Public Attributes

Friends

Detailed Description

Member Enumeration Documentation

◆ Space

◆ WeakSelector

Constructor & Destructor Documentation

◆ ~Heap()

Member Function Documentation

◆ Allocate()

◆ AllocatedExternal()

◆ CapacityInWords()

◆ CheckCatchUp()

◆ CheckConcurrentMarking()

◆ CheckExternalGC()

◆ CheckFinalizeMarking()

◆ CodeContains()

◆ CollectAllGarbage()

◆ CollectGarbage()

◆ Collections()

◆ CollectOnNthAllocation()

◆ Contains()

◆ CreateAllocatedObjectSet()

◆ DataContains()

◆ ExternalInWords()

◆ ForwardWeakEntries()

◆ ForwardWeakTables()

◆ FreedExternal()

◆ GCReasonToString()

◆ GCTimeInMicros()

◆ GCTypeToString()

◆ GetCanonicalHash()

◆ GetHash()

◆ GetLoadingUnit()

◆ GetObjectId()

◆ GetPeer()

◆ GetWeakEntry()

◆ GetWeakTable()

◆ Init()

◆ is_vm_isolate()

◆ isolate_group()

◆ mode()

◆ new_space()

◆ NewContains()

◆ NotifyDestroyed()

◆ NotifyIdle()

◆ old_space()

◆ OldContains()

◆ PeerCount()

◆ PrintHeapMapToJSONStream()

◆ PrintMemoryUsageJSON() [1/2]

◆ PrintMemoryUsageJSON() [2/2]

◆ PrintSizes()

◆ PrintToJSONObject()

◆ PromotedExternal()

◆ ReachabilityBarrier()

◆ ReportSurvivingAllocations()

◆ ResetCanonicalHashTable()

◆ ResetObjectIdTable()

◆ SetCanonicalHash()

◆ SetHashIfNotSet()

◆ SetHeapSamplingData()

◆ SetLoadingUnit()

◆ SetMode()

◆ SetObjectId()

◆ SetPeer()

◆ SetupImagePage()

◆ SetWeakEntry()

◆ SetWeakEntryIfNonExistent()

◆ SetWeakTable()

◆ SpaceForExternal()

◆ StartConcurrentMarking()

◆ TotalCapacityInWords()

◆ TotalExternalInWords()

◆ TotalUsedInWords()

◆ UpdateGlobalMaxUsed()

◆ UsedInWords()