De-duplicate code by adding size-independent iteration.

runtime/vm/pages.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/pages.h"
 
 #include "platform/assert.h"
 #include "vm/compiler_stats.h"
 #include "vm/gc_marker.h"
 #include "vm/gc_sweeper.h"
@@ skipping 278 matching lines @@
   usage_.external_in_words -= size_in_words;
 }
 
 
 bool PageSpace::Contains(uword addr) const {
   HeapPage* page = pages_;
   while (page != NULL) {
     if (page->Contains(addr)) {
       return true;
     }
-    page = page->next();
-  }
-
-  page = large_pages_;
-  while (page != NULL) {
-    if (page->Contains(addr)) {
-      return true;
-    }
-    page = page->next();
+    page = NextPageAnySize(page);
   }
   return false;
 }
 
 
 bool PageSpace::Contains(uword addr, HeapPage::PageType type) const {
   HeapPage* page = pages_;
   while (page != NULL) {
     if ((page->type() == type) && page->Contains(addr)) {
       return true;
     }
-    page = page->next();
-  }
-
-  page = large_pages_;
-  while (page != NULL) {
-    if ((page->type() == type) && page->Contains(addr)) {
-      return true;
-    }
-    page = page->next();
+    page = NextPageAnySize(page);
   }
   return false;
 }
 
 
 void PageSpace::StartEndAddress(uword* start, uword* end) const {
   ASSERT(pages_ != NULL || large_pages_ != NULL);
   *start = static_cast<uword>(~0);
   *end = 0;
-  for (HeapPage* page = pages_; page != NULL; page = page->next()) {
-    *start = Utils::Minimum(*start, page->object_start());
-    *end = Utils::Maximum(*end, page->object_end());
-  }
-  for (HeapPage* page = large_pages_; page != NULL; page = page->next()) {
+  for (HeapPage* page = pages_; page != NULL; page = NextPageAnySize(page)) {
     *start = Utils::Minimum(*start, page->object_start());
     *end = Utils::Maximum(*end, page->object_end());
   }
   ASSERT(*start != static_cast<uword>(~0));
   ASSERT(*end != 0);
 }
 
 
 void PageSpace::VisitObjects(ObjectVisitor* visitor) const {
   HeapPage* page = pages_;
   while (page != NULL) {
     page->VisitObjects(visitor);
-    page = page->next();
-  }
-
-  page = large_pages_;
-  while (page != NULL) {
-    page->VisitObjects(visitor);
-    page = page->next();
+    page = NextPageAnySize(page);
   }
 }
 
 
 void PageSpace::VisitObjectPointers(ObjectPointerVisitor* visitor) const {
   HeapPage* page = pages_;
   while (page != NULL) {
     page->VisitObjectPointers(visitor);
-    page = page->next();
-  }
-
-  page = large_pages_;
-  while (page != NULL) {
-    page->VisitObjectPointers(visitor);
-    page = page->next();
+    page = NextPageAnySize(page);
   }
 }
 
 
 RawObject* PageSpace::FindObject(FindObjectVisitor* visitor,
                                  HeapPage::PageType type) const {
   ASSERT(Isolate::Current()->no_gc_scope_depth() != 0);
   HeapPage* page = pages_;
   while (page != NULL) {
     if (page->type() == type) {
       RawObject* obj = page->FindObject(visitor);
       if (obj != Object::null()) {
         return obj;
       }
     }
-    page = page->next();
-  }
-
-  page = large_pages_;
-  while (page != NULL) {
-    if (page->type() == type) {
-      RawObject* obj = page->FindObject(visitor);
-      if (obj != Object::null()) {
-        return obj;
-      }
-    }
-    page = page->next();
+    page = NextPageAnySize(page);
   }
   return Object::null();
 }
 
 
 void PageSpace::WriteProtect(bool read_only) {
   HeapPage* page = pages_;
   while (page != NULL) {
     page->WriteProtect(read_only);
-    page = page->next();
-  }
-  page = large_pages_;
-  while (page != NULL) {
-    page->WriteProtect(read_only);
-    page = page->next();
+    page = NextPageAnySize(page);
   }
 }
 
 
 void PageSpace::PrintToJSONObject(JSONObject* object) {
   JSONObject space(object, "old");
   space.AddProperty("type", "PageSpace");
   space.AddProperty("id", "heaps/old");
   space.AddProperty("name", "PageSpace");
   space.AddProperty("user_name", "old");
@@ skipping 88 matching lines @@
 
   const int64_t start = OS::GetCurrentTimeMicros();
 
   if (FLAG_write_protect_code) {
     // Make code pages writable.
     HeapPage* current_page = pages_;
     while (current_page != NULL) {
       if (current_page->type() == HeapPage::kExecutable) {
         current_page->WriteProtect(false);
       }
-      current_page = current_page->next();
-    }
-    current_page = large_pages_;
-    while (current_page != NULL) {
-      if (current_page->type() == HeapPage::kExecutable) {
-        current_page->WriteProtect(false);
-      }
-      current_page = current_page->next();
+      current_page = NextPageAnySize(current_page);
     }
   }
 
   // Save old value before GCMarker visits the weak persistent handles.
   SpaceUsage usage_before = usage_;
 
   // Mark all reachable old-gen objects.
   bool collect_code = FLAG_collect_code && ShouldCollectCode();
   GCMarker marker(heap_);
   marker.MarkObjects(isolate, this, invoke_api_callbacks, collect_code);
@@ skipping 40 matching lines @@
     page = next_page;
   }
 
   if (FLAG_write_protect_code) {
     // Make code pages read-only.
     HeapPage* current_page = pages_;
     while (current_page != NULL) {
       if (current_page->type() == HeapPage::kExecutable) {
         current_page->WriteProtect(true);
       }
-      current_page = current_page->next();
-    }
-    current_page = large_pages_;
-    while (current_page != NULL) {
-      if (current_page->type() == HeapPage::kExecutable) {
-        current_page->WriteProtect(true);
-      }
-      current_page = current_page->next();
+      current_page = NextPageAnySize(current_page);
     }
   }
 
   int64_t end = OS::GetCurrentTimeMicros();
 
   // Record signals for growth control. Include size of external allocations.
   page_space_controller_.EvaluateGarbageCollection(usage_before, usage_,
                                                    start, end);
 
   heap_->RecordTime(kMarkObjects, mid1 - start);
@@ skipping 134 matching lines @@
     return 0;
   } else {
     ASSERT(total_time >= gc_time);
     int result= static_cast<int>((static_cast<double>(gc_time) /
                              static_cast<double>(total_time)) * 100);
     return result;
   }
 }
 
 }  // namespace dart