dart::Scavenger Class Reference

#include <scavenger.h>

Public Member Functions
	Scavenger (Heap *heap, intptr_t max_semi_capacity_in_words)
	~Scavenger ()
bool	Contains (uword addr) const
uword	TryAllocate (Thread *thread, intptr_t size)
uword	TryAllocateNoSafepoint (Thread *thread, intptr_t size)
intptr_t	AbandonRemainingTLAB (Thread *thread)
void	AbandonRemainingTLABForDebugging (Thread *thread)
void	Scavenge (Thread *thread, GCType type, GCReason reason)
intptr_t	UsedInWords () const
intptr_t	CapacityInWords () const
intptr_t	ExternalInWords () const
SpaceUsage	GetCurrentUsage () const
intptr_t	ThresholdInWords () const
void	VisitObjects (ObjectVisitor *visitor) const
void	VisitObjectPointers (ObjectPointerVisitor *visitor) const
void	AddRegionsToObjectSet (ObjectSet *set) const
void	WriteProtect (bool read_only)
bool	ShouldPerformIdleScavenge (int64_t deadline)
void	AddGCTime (int64_t micros)
int64_t	gc_time_micros () const
void	IncrementCollections ()
intptr_t	collections () const
void	PrintToJSONObject (JSONObject *object) const
bool	AllocatedExternal (intptr_t size)
void	FreedExternal (intptr_t size)
void	set_freed_in_words (intptr_t value)
Page *	head () const
void	PruneNew ()
void	PruneDeferred ()
void	Forward (MarkingStackBlock *blocks)
void	ForwardDeferred ()
void	PruneWeak (GCLinkedLists *delayed)
template<typename Type , typename PtrType >
void	PruneWeak (GCLinkedList< Type, PtrType > *list)

Static Public Member Functions
static intptr_t	MaxMutatorThreadCount ()

Friends
template<bool >
class	ScavengerVisitorBase

Detailed Description

Definition at line 124 of file scavenger.h.

Constructor & Destructor Documentation

Scavenger()

dart::Scavenger::Scavenger	(	Heap *	heap,
		intptr_t	max_semi_capacity_in_words
	)

Definition at line 824 of file scavenger.cc.

    : heap_(heap),
      max_semi_capacity_in_words_(max_semi_capacity_in_words),
      scavenge_words_per_micro_(kConservativeInitialScavengeSpeed) {
  ASSERT(heap != nullptr);
 
  // Verify assumptions about the first word in objects which the scavenger is
  // going to use for forwarding pointers.
  ASSERT(Object::tags_offset() == 0);
 
  // Set initial semi space size in words.
  const intptr_t initial_semi_capacity_in_words = Utils::Minimum(
      max_semi_capacity_in_words, FLAG_new_gen_semi_initial_size * MBInWords);
 
  to_ = new SemiSpace(initial_semi_capacity_in_words);
  idle_scavenge_threshold_in_words_ = initial_semi_capacity_in_words;
 
  UpdateMaxHeapCapacity();
  UpdateMaxHeapUsage();
}

~Scavenger()

dart::Scavenger::~Scavenger

(

)

Definition at line 845 of file scavenger.cc.

                      {
  ASSERT(!scavenging_);
  delete to_;
  ASSERT(blocks_ == nullptr);
}

Member Function Documentation

AbandonRemainingTLAB()

intptr_t dart::Scavenger::AbandonRemainingTLAB

(

Thread *

thread

)

Definition at line 1863 of file scavenger.cc.

                                                       {
  if (thread->top() == 0) return 0;
 
  Page* page = Page::Of(thread->top() - 1);
  intptr_t allocated;
  {
    if (thread->is_marking()) {
      thread->DeferredMarkLiveTemporaries();
    }
    MutexLocker ml(&space_lock_);
    allocated = page->Release(thread);
  }
  ASSERT(thread->top() == 0);
  return allocated;
}

AbandonRemainingTLABForDebugging()

void dart::Scavenger::AbandonRemainingTLABForDebugging

(

Thread *

thread

)

Definition at line 1850 of file scavenger.cc.

                                                               {
  // Allocate any remaining space so the TLAB won't be reused. Write a filler
  // object so it remains iterable.
  uword top = thread->top();
  intptr_t size = thread->end() - thread->top();
  if (size > 0) {
    thread->set_top(top + size);
    ForwardingCorpse::AsForwarder(top, size);
  }
 
  AbandonRemainingTLAB(thread);
}

AddGCTime()

void dart::Scavenger::AddGCTime ( int64_t  micros )

inline

Definition at line 187 of file scavenger.h.

{ gc_time_micros_ += micros; }

AddRegionsToObjectSet()

void dart::Scavenger::AddRegionsToObjectSet

(

ObjectSet *

set

)

const

Definition at line 1793 of file scavenger.cc.

                                                          {
  for (Page* page = to_->head(); page != nullptr; page = page->next()) {
    set->AddRegion(page->start(), page->end());
  }
}

AllocatedExternal()

bool dart::Scavenger::AllocatedExternal ( intptr_t  size )

inline

Definition at line 202 of file scavenger.h.

                                        {
    ASSERT(size >= 0);
    intptr_t expected = external_size_.load();
    intptr_t desired;
    do {
      intptr_t next_external_size_in_words =
          (external_size_ >> kWordSizeLog2) + (size >> kWordSizeLog2);
      if (next_external_size_in_words < 0 ||
          next_external_size_in_words > kMaxAddrSpaceInWords) {
        return false;
      }
      desired = expected + size;
      ASSERT(desired >= 0);
    } while (!external_size_.compare_exchange_weak(expected, desired));
    return true;
  }

CapacityInWords()

intptr_t dart::Scavenger::CapacityInWords ( ) const

inline

Definition at line 164 of file scavenger.h.

                                   {
    MutexLocker ml(&space_lock_);
    return to_->capacity_in_words();
  }

collections()

intptr_t dart::Scavenger::collections ( ) const

inline

Definition at line 193 of file scavenger.h.

{ return collections_; }

Contains()

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

inline

Definition at line 136 of file scavenger.h.

{ return to_->Contains(addr); }

ExternalInWords()

intptr_t dart::Scavenger::ExternalInWords ( ) const

inline

Definition at line 168 of file scavenger.h.

{ return external_size_ >> kWordSizeLog2; }

Forward()

void dart::Scavenger::Forward

(

MarkingStackBlock *

blocks

)

Definition at line 1524 of file scavenger.cc.

                                                  {
  ASSERT(abort_);
 
  GCMarker* marker = heap_->old_space()->marker();
  MarkingStack* old_marking_stack = &marker->old_marking_stack_;
  MarkingStack* new_marking_stack = &marker->new_marking_stack_;
  MarkingStackBlock* old_writing = old_marking_stack->PopNonFullBlock();
  MarkingStackBlock* new_writing = new_marking_stack->PopNonFullBlock();
  while (reading != nullptr) {
    // Generated code appends to marking stacks; tell MemorySanitizer.
    MSAN_UNPOISON(reading, sizeof(*reading));
    while (!reading->IsEmpty()) {
      ObjectPtr obj = reading->Pop();
      ASSERT(obj->IsHeapObject());
#if defined(DEBUG)
      if (obj->IsNewObject()) {
        uword header = ReadHeaderRelaxed(obj);
        ASSERT(!IsForwarding(header));
      }
#endif
      if (obj->IsForwardingCorpse()) {
        // Promoted object was pushed to mark list but reversed.
        obj = reinterpret_cast<ForwardingCorpse*>(UntaggedObject::ToAddr(obj))
                  ->target();
      }
      ASSERT(!obj->IsForwardingCorpse());
      ASSERT(!obj->IsFreeListElement());
      if (obj->IsNewObject()) {
        new_writing->Push(obj);
        if (new_writing->IsFull()) {
          new_marking_stack->PushBlock(new_writing);
          new_writing = new_marking_stack->PopNonFullBlock();
        }
      } else {
        old_writing->Push(obj);
        if (old_writing->IsFull()) {
          old_marking_stack->PushBlock(old_writing);
          old_writing = old_marking_stack->PopNonFullBlock();
        }
      }
    }
 
    MarkingStackBlock* next = reading->next();
    reading->Reset();
    old_marking_stack->PushBlock(reading);
    reading = next;
  }
  old_marking_stack->PushBlock(old_writing);
  new_marking_stack->PushBlock(new_writing);
}

ForwardDeferred()

void dart::Scavenger::ForwardDeferred

(

)

Definition at line 1575 of file scavenger.cc.

                                {
  ASSERT(abort_);
 
  class ReverseMarkStack : public ObjectPointerVisitor {
   public:
    explicit ReverseMarkStack(IsolateGroup* group)
        : ObjectPointerVisitor(group) {}
 
    void VisitPointers(ObjectPtr* first, ObjectPtr* last) override {
      for (ObjectPtr* p = first; p <= last; p++) {
        ObjectPtr obj = *p;
#if defined(DEBUG)
        if (obj->IsNewObject()) {
          uword header = ReadHeaderRelaxed(obj);
          ASSERT(!IsForwarding(header));
        }
#endif
        if (obj->IsForwardingCorpse()) {
          // Promoted object was pushed to mark list but reversed.
          *p = reinterpret_cast<ForwardingCorpse*>(UntaggedObject::ToAddr(obj))
                   ->target();
        }
      }
    }
#if defined(DART_COMPRESSED_POINTERS)
    void VisitCompressedPointers(uword heap_base,
                                 CompressedObjectPtr* first,
                                 CompressedObjectPtr* last) override {
      UNREACHABLE();
    }
#endif
  };
 
  ReverseMarkStack visitor(heap_->isolate_group());
  heap_->old_space()->marker()->deferred_marking_stack_.VisitObjectPointers(
      &visitor);
}

FreedExternal()

void dart::Scavenger::FreedExternal ( intptr_t  size )

inline

Definition at line 218 of file scavenger.h.

                                    {
    ASSERT(size >= 0);
    external_size_ -= size;
    ASSERT(external_size_ >= 0);
  }

gc_time_micros()

int64_t dart::Scavenger::gc_time_micros ( ) const

inline

Definition at line 189 of file scavenger.h.

{ return gc_time_micros_; }

GetCurrentUsage()

SpaceUsage dart::Scavenger::GetCurrentUsage ( ) const

inline

Definition at line 169 of file scavenger.h.

                                     {
    SpaceUsage usage;
    usage.used_in_words = UsedInWords();
    usage.capacity_in_words = CapacityInWords();
    usage.external_in_words = ExternalInWords();
    return usage;
  }

head()

Page * dart::Scavenger::head ( ) const

inline

Definition at line 237 of file scavenger.h.

{ return to_->head(); }

IncrementCollections()

void dart::Scavenger::IncrementCollections ( )

inline

Definition at line 191 of file scavenger.h.

{ collections_++; }

MaxMutatorThreadCount()

static intptr_t dart::Scavenger::MaxMutatorThreadCount ( )

inlinestatic

Definition at line 228 of file scavenger.h.

                                          {
    // With a max new-space of 16 MB and 512kb TLABs we would allow up to 8
    // mutator threads to run at the same time.
    const intptr_t max_parallel_tlab_usage =
        (FLAG_new_gen_semi_max_size * MB) / Scavenger::kTLABSize;
    const intptr_t max_pool_size = max_parallel_tlab_usage / 4;
    return max_pool_size > 0 ? max_pool_size : 1;
  }

PrintToJSONObject()

void dart::Scavenger::PrintToJSONObject

(

JSONObject *

object

)

const

Definition at line 2132 of file scavenger.cc.

                                                          {
  auto isolate_group = IsolateGroup::Current();
  ASSERT(isolate_group != nullptr);
  JSONObject space(object, "new");
  space.AddProperty("type", "HeapSpace");
  space.AddProperty("name", "new");
  space.AddProperty("vmName", "Scavenger");
  space.AddProperty("collections", collections());
  if (collections() > 0) {
    int64_t run_time = isolate_group->UptimeMicros();
    run_time = Utils::Maximum(run_time, static_cast<int64_t>(0));
    double run_time_millis = MicrosecondsToMilliseconds(run_time);
    double avg_time_between_collections =
        run_time_millis / static_cast<double>(collections());
    space.AddProperty("avgCollectionPeriodMillis",
                      avg_time_between_collections);
  } else {
    space.AddProperty("avgCollectionPeriodMillis", 0.0);
  }
  space.AddProperty64("used", UsedInWords() * kWordSize);
  space.AddProperty64("capacity", CapacityInWords() * kWordSize);
  space.AddProperty64("external", ExternalInWords() * kWordSize);
  space.AddProperty("time", MicrosecondsToSeconds(gc_time_micros()));
}

PruneDeferred()

void dart::Scavenger::PruneDeferred

(

)

Definition at line 1662 of file scavenger.cc.

                              {
  ASSERT(!abort_);
  TIMELINE_FUNCTION_GC_DURATION(Thread::Current(), "PruneDeferredMarkingStack");
  MarkingStackBlock* reading;
  GCMarker* marker = heap_->old_space()->marker();
  MarkingStack* marking_stack = &marker->deferred_marking_stack_;
  MarkingStackBlock* writing = marking_stack->PopNonFullBlock();
  for (;;) {
    {
      MutexLocker ml(&space_lock_);
      reading = deferred_blocks_;
      if (reading == nullptr) break;
      deferred_blocks_ = reading->next();
    }
    // Generated code appends to marking stacks; tell MemorySanitizer.
    MSAN_UNPOISON(reading, sizeof(*reading));
    while (!reading->IsEmpty()) {
      ObjectPtr obj = reading->Pop();
      ASSERT(obj->IsHeapObject());
      if (obj->IsNewObject()) {
        uword header = ReadHeaderRelaxed(obj);
        if (!IsForwarding(header)) continue;
        obj = ForwardedObj(header);
      }
      ASSERT(!obj->IsForwardingCorpse());
      ASSERT(!obj->IsFreeListElement());
      writing->Push(obj);
      if (writing->IsFull()) {
        marking_stack->PushBlock(writing);
        writing = marking_stack->PopNonFullBlock();
      }
    }
    reading->Reset();
    marking_stack->PushBlock(reading);
  }
  marking_stack->PushBlock(writing);
}

PruneNew()

void dart::Scavenger::PruneNew

(

)

Definition at line 1613 of file scavenger.cc.

                         {
  ASSERT(!abort_);
  TIMELINE_FUNCTION_GC_DURATION(Thread::Current(), "PruneNewMarkingStack");
  MarkingStackBlock* reading;
  GCMarker* marker = heap_->old_space()->marker();
  MarkingStack* old_marking_stack = &marker->old_marking_stack_;
  MarkingStack* new_marking_stack = &marker->new_marking_stack_;
  MarkingStackBlock* old_writing = old_marking_stack->PopNonFullBlock();
  MarkingStackBlock* new_writing = new_marking_stack->PopNonFullBlock();
  for (;;) {
    {
      MutexLocker ml(&space_lock_);
      reading = new_blocks_;
      if (reading == nullptr) break;
      new_blocks_ = reading->next();
    }
    // Generated code appends to marking stacks; tell MemorySanitizer.
    MSAN_UNPOISON(reading, sizeof(*reading));
    while (!reading->IsEmpty()) {
      ObjectPtr obj = reading->Pop();
      ASSERT(obj->IsHeapObject());
      if (obj->IsNewObject()) {
        uword header = ReadHeaderRelaxed(obj);
        if (!IsForwarding(header)) continue;
        obj = ForwardedObj(header);
      }
      ASSERT(!obj->IsForwardingCorpse());
      ASSERT(!obj->IsFreeListElement());
      if (obj->IsNewObject()) {
        new_writing->Push(obj);
        if (new_writing->IsFull()) {
          new_marking_stack->PushBlock(new_writing);
          new_writing = new_marking_stack->PopNonFullBlock();
        }
      } else {
        old_writing->Push(obj);
        if (old_writing->IsFull()) {
          old_marking_stack->PushBlock(old_writing);
          old_writing = old_marking_stack->PopNonFullBlock();
        }
      }
    }
    reading->Reset();
    new_marking_stack->PushBlock(reading);
  }
  old_marking_stack->PushBlock(old_writing);
  new_marking_stack->PushBlock(new_writing);
}

PruneWeak() [1/2]

template<typename Type , typename PtrType >

void dart::Scavenger::PruneWeak

(

GCLinkedList< Type, PtrType > *

list

)

Definition at line 1710 of file scavenger.cc.

                                                           {
  PtrType weak = list->Release();
  while (weak != Object::null()) {
    PtrType next;
    if (weak->IsOldObject()) {
      ASSERT(weak->GetClassId() == Type::kClassId);
      next = weak->untag()->next_seen_by_gc_.Decompress(weak->heap_base());
      weak->untag()->next_seen_by_gc_ = Type::null();
      list->Enqueue(weak);
    } else {
      uword header = ReadHeaderRelaxed(weak);
      if (IsForwarding(header)) {
        weak = static_cast<PtrType>(ForwardedObj(header));
        ASSERT(weak->GetClassId() == Type::kClassId);
        next = weak->untag()->next_seen_by_gc_.Decompress(weak->heap_base());
        weak->untag()->next_seen_by_gc_ = Type::null();
        list->Enqueue(weak);
      } else {
        // Collected in this scavenge.
        ASSERT(weak->GetClassId() == Type::kClassId);
        next = weak->untag()->next_seen_by_gc_.Decompress(weak->heap_base());
      }
    }
 
    weak = next;
  }
}

PruneWeak() [2/2]

void dart::Scavenger::PruneWeak

(

GCLinkedLists *

delayed

)

Definition at line 1700 of file scavenger.cc.

                                                 {
  ASSERT(!abort_);
  TIMELINE_FUNCTION_GC_DURATION(Thread::Current(), "PruneWeak");
  PruneWeak(&deferred->weak_properties);
  PruneWeak(&deferred->weak_references);
  PruneWeak(&deferred->weak_arrays);
  PruneWeak(&deferred->finalizer_entries);
}

Scavenge()

void dart::Scavenger::Scavenge	(	Thread *	thread,
		GCType	type,
		GCReason	reason
	)

Definition at line 1901 of file scavenger.cc.

                                                                     {
  int64_t start = OS::GetCurrentMonotonicMicros();
 
  ASSERT(thread->OwnsGCSafepoint());
 
  // Scavenging is not reentrant. Make sure that is the case.
  ASSERT(!scavenging_);
  scavenging_ = true;
 
  if (type == GCType::kEvacuate) {
    // Forces the next scavenge to promote all the objects in the new space.
    early_tenure_ = true;
  }
 
  if (FLAG_verify_before_gc) {
    heap_->WaitForSweeperTasksAtSafepoint(thread);
    heap_->VerifyGC("Verifying before Scavenge",
                    thread->is_marking() ? kAllowMarked : kForbidMarked);
  }
 
  // Prepare for a scavenge.
  failed_to_promote_ = false;
  abort_ = false;
  root_slices_started_ = 0;
  weak_slices_started_ = 0;
  freed_in_words_ = 0;
  intptr_t abandoned_bytes = 0;  // TODO(rmacnak): Count fragmentation?
  SpaceUsage usage_before = GetCurrentUsage();
  intptr_t promo_candidate_words = 0;
  for (Page* page = to_->head(); page != nullptr; page = page->next()) {
    page->Release();
    if (early_tenure_) {
      page->EarlyTenure();
    }
    promo_candidate_words += page->promo_candidate_words();
  }
  heap_->old_space()->PauseConcurrentMarking();
  SemiSpace* from = Prologue(reason);
 
  intptr_t bytes_promoted;
  if (FLAG_scavenger_tasks == 0) {
    bytes_promoted = SerialScavenge(from);
  } else {
    bytes_promoted = ParallelScavenge(from);
  }
  if (abort_) {
    ReverseScavenge(&from);
    bytes_promoted = 0;
  } else {
    if ((ThresholdInWords() - UsedInWords()) < KBInWords) {
      // Don't scavenge again until the next old-space GC has occurred. Prevents
      // performing one scavenge per allocation as the heap limit is approached.
      heap_->assume_scavenge_will_fail_ = true;
    }
  }
  ASSERT(promotion_stack_.IsEmpty());
 
  // Scavenge finished. Run accounting.
  int64_t end = OS::GetCurrentMonotonicMicros();
  stats_history_.Add(ScavengeStats(
      start, end, usage_before, GetCurrentUsage(), promo_candidate_words,
      bytes_promoted >> kWordSizeLog2, abandoned_bytes >> kWordSizeLog2));
  Epilogue(from);
  heap_->old_space()->ResumeConcurrentMarking();
 
  if (FLAG_verify_after_gc) {
    heap_->WaitForSweeperTasksAtSafepoint(thread);
    heap_->VerifyGC("Verifying after Scavenge...",
                    thread->is_marking() ? kAllowMarked : kForbidMarked);
  }
 
  // Done scavenging. Reset the marker.
  ASSERT(scavenging_);
  scavenging_ = false;
 
  // It is possible for objects to stay in the new space
  // if the VM cannot create more pages for these objects.
  ASSERT((type != GCType::kEvacuate) || (UsedInWords() == 0) ||
         failed_to_promote_);
}

set_freed_in_words()

void dart::Scavenger::set_freed_in_words ( intptr_t  value )

inline

Definition at line 224 of file scavenger.h.

{ freed_in_words_ = value; }

ShouldPerformIdleScavenge()

bool dart::Scavenger::ShouldPerformIdleScavenge

(

int64_t

deadline

)

Definition at line 1170 of file scavenger.cc.

                                                          {
  // To make a consistent decision, we should not yield for a safepoint in the
  // middle of deciding whether to perform an idle GC.
  NoSafepointScope no_safepoint;
 
  // TODO(rmacnak): Investigate collecting a history of idle period durations.
  intptr_t used_in_words = UsedInWords() + freed_in_words_;
  intptr_t external_in_words = ExternalInWords();
  // Normal reason: new space is getting full.
  bool for_new_space = (used_in_words >= idle_scavenge_threshold_in_words_) ||
                       (external_in_words >= idle_scavenge_threshold_in_words_);
  if (!for_new_space) {
    return false;
  }
 
  int64_t estimated_scavenge_completion =
      OS::GetCurrentMonotonicMicros() +
      used_in_words / scavenge_words_per_micro_;
  return estimated_scavenge_completion <= deadline;
}

ThresholdInWords()

intptr_t dart::Scavenger::ThresholdInWords ( ) const

inline

Definition at line 176 of file scavenger.h.

{ return to_->gc_threshold_in_words(); }

TryAllocate()

uword dart::Scavenger::TryAllocate ( Thread *  thread, intptr_t  size  )

inline

Definition at line 138 of file scavenger.h.

                                                   {
    uword addr = TryAllocateFromTLAB(thread, size);
    if (LIKELY(addr != 0)) {
      return addr;
    }
    TryAllocateNewTLAB(thread, size, true);
    return TryAllocateFromTLAB(thread, size);
  }

TryAllocateNoSafepoint()

uword dart::Scavenger::TryAllocateNoSafepoint ( Thread *  thread, intptr_t  size  )

inline

Definition at line 146 of file scavenger.h.

                                                              {
    uword addr = TryAllocateFromTLAB(thread, size);
    if (LIKELY(addr != 0)) {
      return addr;
    }
    TryAllocateNewTLAB(thread, size, false);
    return TryAllocateFromTLAB(thread, size);
  }

UsedInWords()

intptr_t dart::Scavenger::UsedInWords ( ) const

inline

Definition at line 160 of file scavenger.h.

                               {
    MutexLocker ml(&space_lock_);
    return to_->used_in_words() - freed_in_words_;
  }

VisitObjectPointers()

void dart::Scavenger::VisitObjectPointers

(

ObjectPointerVisitor *

visitor

)

const

Definition at line 1775 of file scavenger.cc.

                                                                       {
  ASSERT(Thread::Current()->OwnsGCSafepoint() ||
         (Thread::Current()->task_kind() == Thread::kMarkerTask) ||
         (Thread::Current()->task_kind() == Thread::kCompactorTask));
  for (Page* page = to_->head(); page != nullptr; page = page->next()) {
    page->VisitObjectPointers(visitor);
  }
}

VisitObjects()

void dart::Scavenger::VisitObjects

(

ObjectVisitor *

visitor

)

const

Definition at line 1784 of file scavenger.cc.

                                                         {
  ASSERT(Thread::Current()->OwnsGCSafepoint() ||
         (Thread::Current()->task_kind() == Thread::kMarkerTask) ||
         (Thread::Current()->task_kind() == Thread::kIncrementalCompactorTask));
  for (Page* page = to_->head(); page != nullptr; page = page->next()) {
    page->VisitObjects(visitor);
  }
}

WriteProtect()

void dart::Scavenger::WriteProtect

(

bool

read_only

)

Definition at line 2126 of file scavenger.cc.

                                           {
  ASSERT(!scavenging_);
  to_->WriteProtect(read_only);
}

Friends And Related Function Documentation

ScavengerVisitorBase

template<bool >

friend class ScavengerVisitorBase

friend

Definition at line 336 of file scavenger.h.

---

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

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