Add Heap::isolate_ to simplify code.

runtime/vm/heap.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/heap.h"
 
 #include "platform/assert.h"
 #include "platform/utils.h"
 #include "vm/flags.h"
 #include "vm/isolate.h"
@@ skipping 14 matching lines @@
 DEFINE_FLAG(bool, verbose_gc, false, "Enables verbose GC.");
 DEFINE_FLAG(int, verbose_gc_hdr, 40, "Print verbose GC header interval.");
 DEFINE_FLAG(bool, verify_before_gc, false,
             "Enables heap verification before GC.");
 DEFINE_FLAG(bool, verify_after_gc, false,
             "Enables heap verification after GC.");
 DEFINE_FLAG(bool, gc_at_alloc, false, "GC at every allocation.");
 DEFINE_FLAG(int, new_gen_ext_limit, 64,
             "maximum total external size (MB) in new gen before triggering GC");
 
-Heap::Heap(intptr_t max_new_gen_words,
+Heap::Heap(Isolate* isolate,
+           intptr_t max_new_gen_words,
            intptr_t max_old_gen_words)
-    : read_only_(false), gc_in_progress_(false) {
+    : isolate_(isolate), read_only_(false), gc_in_progress_(false) {
   for (int sel = 0;
        sel < kNumWeakSelectors;
        sel++) {
     new_weak_tables_[sel] = new WeakTable();
     old_weak_tables_[sel] = new WeakTable();
   }
   new_space_ = new Scavenger(this,
                              max_new_gen_words,
                              kNewObjectAlignmentOffset);
   old_space_ = new PageSpace(this, max_old_gen_words);
   stats_.num_ = 0;
 }
 
 
 Heap::~Heap() {
   delete new_space_;
   delete old_space_;
   for (int sel = 0;
        sel < kNumWeakSelectors;
        sel++) {
     delete new_weak_tables_[sel];
     delete old_weak_tables_[sel];
   }
 }
 
 
 uword Heap::AllocateNew(intptr_t size) {
-  ASSERT(Isolate::Current()->no_gc_scope_depth() == 0);
+  ASSERT(isolate()->no_gc_scope_depth() == 0);
   uword addr = new_space_->TryAllocate(size);
   if (addr == 0) {
     CollectGarbage(kNew);
     addr = new_space_->TryAllocate(size);
     if (addr == 0) {
       return AllocateOld(size, HeapPage::kData);
     }
   }
   return addr;
 }
 
 
 uword Heap::AllocateOld(intptr_t size, HeapPage::PageType type) {
-  ASSERT(Isolate::Current()->no_gc_scope_depth() == 0);
+  ASSERT(isolate()->no_gc_scope_depth() == 0);
   uword addr = old_space_->TryAllocate(size, type);
   if (addr == 0) {
     CollectAllGarbage();
     addr = old_space_->TryAllocate(size, type, PageSpace::kForceGrowth);
     if (addr == 0) {
       OS::PrintErr("Exhausted heap space, trying to allocate %" Pd " bytes.\n",
                    size);
       return 0;
     }
   }
@@ skipping 45 matching lines @@
 bool Heap::OldContains(uword addr) const {
   return old_space_->Contains(addr);
 }
 
 
 bool Heap::CodeContains(uword addr) const {
   return old_space_->Contains(addr, HeapPage::kExecutable);
 }
 
 
-void Heap::IterateObjects(ObjectVisitor* visitor) {
+void Heap::IterateObjects(ObjectVisitor* visitor) const {
   new_space_->VisitObjects(visitor);
   old_space_->VisitObjects(visitor);
 }
 
 
-void Heap::IteratePointers(ObjectPointerVisitor* visitor) {
+void Heap::IteratePointers(ObjectPointerVisitor* visitor) const {
   new_space_->VisitObjectPointers(visitor);
   old_space_->VisitObjectPointers(visitor);
 }
 
 
-void Heap::IterateNewPointers(ObjectPointerVisitor* visitor) {
+void Heap::IterateNewPointers(ObjectPointerVisitor* visitor) const {
   new_space_->VisitObjectPointers(visitor);
 }
 
 
-void Heap::IterateOldPointers(ObjectPointerVisitor* visitor) {
+void Heap::IterateOldPointers(ObjectPointerVisitor* visitor) const {
   old_space_->VisitObjectPointers(visitor);
 }
 
 
-void Heap::IterateNewObjects(ObjectVisitor* visitor) {
+void Heap::IterateNewObjects(ObjectVisitor* visitor) const {
   new_space_->VisitObjects(visitor);
 }
 
 
-void Heap::IterateOldObjects(ObjectVisitor* visitor) {
+void Heap::IterateOldObjects(ObjectVisitor* visitor) const {
   old_space_->VisitObjects(visitor);
 }
 
 
 RawInstructions* Heap::FindObjectInCodeSpace(FindObjectVisitor* visitor) const {
   // Only executable pages can have RawInstructions objects.
   RawObject* raw_obj = old_space_->FindObject(visitor, HeapPage::kExecutable);
   ASSERT((raw_obj == Object::null()) ||
          (raw_obj->GetClassId() == kInstructionsCid));
   return reinterpret_cast<RawInstructions*>(raw_obj);
 }
 
 
 RawObject* Heap::FindOldObject(FindObjectVisitor* visitor) const {
   return old_space_->FindObject(visitor, HeapPage::kData);
 }
 
 
 RawObject* Heap::FindNewObject(FindObjectVisitor* visitor) const {
   return new_space_->FindObject(visitor);
 }
 
 
 RawObject* Heap::FindObject(FindObjectVisitor* visitor) const {
-  ASSERT(Isolate::Current()->no_gc_scope_depth() != 0);
+  ASSERT(isolate()->no_gc_scope_depth() != 0);
   RawObject* raw_obj = FindNewObject(visitor);
   if (raw_obj != Object::null()) {
     return raw_obj;
   }
   raw_obj = FindOldObject(visitor);
   if (raw_obj != Object::null()) {
     return raw_obj;
   }
   raw_obj = FindObjectInCodeSpace(visitor);
   return raw_obj;
 }
 
 
 void Heap::CollectGarbage(Space space,
                           ApiCallbacks api_callbacks,
                           GCReason reason) {
-  Isolate* isolate = Isolate::Current();
-  TIMERSCOPE(isolate, time_gc);
+  TIMERSCOPE(isolate(), time_gc);
   bool invoke_api_callbacks = (api_callbacks == kInvokeApiCallbacks);
   switch (space) {
     case kNew: {
-      VMTagScope tagScope(isolate, VMTag::kGCNewSpaceTagId);
+      VMTagScope tagScope(isolate(), VMTag::kGCNewSpaceTagId);
       RecordBeforeGC(kNew, reason);
       UpdateClassHeapStatsBeforeGC(kNew);
       new_space_->Scavenge(invoke_api_callbacks);
       RecordAfterGC();
       PrintStats();
       if (old_space_->NeedsGarbageCollection()) {
         // Old collections should call the API callbacks.
         CollectGarbage(kOld, kInvokeApiCallbacks, kPromotion);
       }
       break;
     }
     case kOld:
     case kCode: {
-      VMTagScope tagScope(isolate, VMTag::kGCOldSpaceTagId);
+      VMTagScope tagScope(isolate(), VMTag::kGCOldSpaceTagId);
       RecordBeforeGC(kOld, reason);
       UpdateClassHeapStatsBeforeGC(kOld);
       old_space_->MarkSweep(invoke_api_callbacks);
       RecordAfterGC();
       PrintStats();
       break;
     }
     default:
       UNREACHABLE();
   }
 }
 
 
 void Heap::UpdateClassHeapStatsBeforeGC(Heap::Space space) {
-  Isolate* isolate = Isolate::Current();
-  ClassTable* class_table = isolate->class_table();
+  ClassTable* class_table = isolate()->class_table();
   if (space == kNew) {
     class_table->ResetCountersNew();
   } else {
     class_table->ResetCountersOld();
   }
 }
 
 
 void Heap::CollectGarbage(Space space) {
   if (space == kOld) {
     CollectGarbage(space, kInvokeApiCallbacks, kOldSpace);
   } else {
     ASSERT(space == kNew);
     CollectGarbage(space, kInvokeApiCallbacks, kNewSpace);
   }
 }
 
 
 void Heap::CollectAllGarbage() {
-  Isolate* isolate = Isolate::Current();
-  TIMERSCOPE(isolate, time_gc);
+  TIMERSCOPE(isolate(), time_gc);
   {
-    VMTagScope tagScope(isolate, VMTag::kGCNewSpaceTagId);
+    VMTagScope tagScope(isolate(), VMTag::kGCNewSpaceTagId);
     RecordBeforeGC(kNew, kFull);
     UpdateClassHeapStatsBeforeGC(kNew);
     new_space_->Scavenge(kInvokeApiCallbacks);
     RecordAfterGC();
     PrintStats();
   }
   {
-    VMTagScope tagScope(isolate, VMTag::kGCOldSpaceTagId);
+    VMTagScope tagScope(isolate(), VMTag::kGCOldSpaceTagId);
     RecordBeforeGC(kOld, kFull);
     UpdateClassHeapStatsBeforeGC(kOld);
     old_space_->MarkSweep(kInvokeApiCallbacks);
     RecordAfterGC();
     PrintStats();
   }
 }
 
 
 void Heap::SetGrowthControlState(bool state) {
@@ skipping 20 matching lines @@
 
 uword Heap::EndAddress() {
   return reinterpret_cast<uword>(new_space_->EndAddress());
 }
 
 
 void Heap::Init(Isolate* isolate,
                 intptr_t max_new_gen_words,
                 intptr_t max_old_gen_words) {
   ASSERT(isolate->heap() == NULL);
-  Heap* heap = new Heap(max_new_gen_words, max_old_gen_words);
+  Heap* heap = new Heap(isolate, max_new_gen_words, max_old_gen_words);
   isolate->set_heap(heap);
 }
 
 
 void Heap::GetMergedAddressRange(uword* start, uword* end) const {
   if (new_space_->CapacityInWords() != 0) {
     uword new_start;
     uword new_end;
     new_space_->StartEndAddress(&new_start, &new_end);
     *start = Utils::Minimum(new_start, *start);
     *end = Utils::Maximum(new_end, *end);
   }
   if (old_space_->CapacityInWords() != 0) {
     uword old_start;
     uword old_end;
     old_space_->StartEndAddress(&old_start, &old_end);
     *start = Utils::Minimum(old_start, *start);
     *end = Utils::Maximum(old_end, *end);
   }
   ASSERT(*start <= *end);
 }
 
 
 ObjectSet* Heap::CreateAllocatedObjectSet() const {
   uword start = static_cast<uword>(-1);
   uword end = 0;
   Isolate* vm_isolate = Dart::vm_isolate();
   vm_isolate->heap()->GetMergedAddressRange(&start, &end);
-  Isolate* isolate = Isolate::Current();
-  ASSERT(isolate->heap() == this);
-  isolate->heap()->GetMergedAddressRange(&start, &end);
+  this->GetMergedAddressRange(&start, &end);

[Ivan Posva, 2014/04/25 16:55:57]

Drop this->?

[koda, 2014/04/25 17:26:06]

When there is another object of the same type around, I think it helps
readability to be explicit about which one is being operated on.

 
   ObjectSet* allocated_set = new ObjectSet(start, end);
 
-  VerifyObjectVisitor object_visitor(isolate, allocated_set);
-  // TODO(koda): Consider adding a const visitor to enable using 'this'.
-  isolate->heap()->IterateObjects(&object_visitor);
+  VerifyObjectVisitor object_visitor(isolate(), allocated_set);
+  this->IterateObjects(&object_visitor);
   vm_isolate->heap()->IterateObjects(&object_visitor);
 
   return allocated_set;
 }
 
 
 bool Heap::Verify() const {
-  Isolate* isolate = Isolate::Current();
-  ASSERT(isolate->heap() == this);
-  ObjectSet* allocated_set = isolate->heap()->CreateAllocatedObjectSet();
-  VerifyPointersVisitor visitor(isolate, allocated_set);
-  // TODO(koda): Consider adding a const visitor to enable using 'this'.
-  isolate->heap()->IteratePointers(&visitor);
+  ObjectSet* allocated_set = CreateAllocatedObjectSet();
+  VerifyPointersVisitor visitor(isolate(), allocated_set);
+  IteratePointers(&visitor);
   delete allocated_set;
   // Only returning a value so that Heap::Validate can be called from an ASSERT.
   return true;
 }
 
 
 void Heap::PrintSizes() const {
   OS::PrintErr("New space (%" Pd "k of %" Pd "k) "
                "Old space (%" Pd "k of %" Pd "k)\n",
                (UsedInWords(kNew) / KBInWords),
@@ skipping 126 matching lines @@
   }
   stats_.after_.new_ = new_space_->GetCurrentUsage();
   stats_.after_.old_ = old_space_->GetCurrentUsage();
   ASSERT(gc_in_progress_);
   gc_in_progress_ = false;
 }
 
 
 void Heap::PrintStats() {
   if (!FLAG_verbose_gc) return;
-  Isolate* isolate = Isolate::Current();
 
   if ((FLAG_verbose_gc_hdr != 0) &&
       (((stats_.num_ - 1) % FLAG_verbose_gc_hdr) == 0)) {
     OS::PrintErr("[    GC    |  space  | count | start | gc time | "
                  "new gen (KB) | old gen (KB) | timers | data ]\n"
                  "[ (isolate)| (reason)|       |  (s)  |   (ms)  | "
                  "used,cap,ext | used,cap,ext |  (ms)  |      ]\n");
   }
 
   const char* space_str = stats_.space_ == kNew ? "Scavenge" : "Mark-Sweep";
   OS::PrintErr(
     "[ GC(%" Pd64 "): %s(%s), "  // GC(isolate), space(reason)
     "%" Pd ", "  // count
     "%.3f, "  // start time
     "%.3f, "  // total time
     "%" Pd ", %" Pd ", "  // new gen: in use before/after
     "%" Pd ", %" Pd ", "  // new gen: capacity before/after
     "%" Pd ", %" Pd ", "  // new gen: external before/after
     "%" Pd ", %" Pd ", "  // old gen: in use before/after
     "%" Pd ", %" Pd ", "  // old gen: capacity before/after
     "%" Pd ", %" Pd ", "  // old gen: external before/after
     "%.3f, %.3f, %.3f, %.3f, "  // times
     "%" Pd ", %" Pd ", %" Pd ", %" Pd ", "  // data
     "]\n",  // End with a comma to make it easier to import in spreadsheets.
-    isolate->main_port(), space_str, GCReasonToString(stats_.reason_),
+    isolate()->main_port(), space_str, GCReasonToString(stats_.reason_),
     stats_.num_,
-    MicrosecondsToSeconds(stats_.before_.micros_ - isolate->start_time()),
+    MicrosecondsToSeconds(stats_.before_.micros_ - isolate()->start_time()),
     MicrosecondsToMilliseconds(stats_.after_.micros_ -
                                     stats_.before_.micros_),
     RoundWordsToKB(stats_.before_.new_.used_in_words),
     RoundWordsToKB(stats_.after_.new_.used_in_words),
     RoundWordsToKB(stats_.before_.new_.capacity_in_words),
     RoundWordsToKB(stats_.after_.new_.capacity_in_words),
     RoundWordsToKB(stats_.before_.new_.external_in_words),
     RoundWordsToKB(stats_.after_.new_.external_in_words),
     RoundWordsToKB(stats_.before_.old_.used_in_words),
     RoundWordsToKB(stats_.after_.old_.used_in_words),
@@ skipping 31 matching lines @@
     heap->DisableGrowthControl();
 }
 
 
 NoHeapGrowthControlScope::~NoHeapGrowthControlScope() {
     Heap* heap = reinterpret_cast<Isolate*>(isolate())->heap();
     heap->SetGrowthControlState(current_growth_controller_state_);
 }
 
 }  // namespace dart