Support old-space allocation in generated code (bump block only for now).

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 385 matching lines @@
   // TODO(koda): Control growth.
 }
 
 
 void PageSpace::FreeExternal(intptr_t size) {
   intptr_t size_in_words = size >> kWordSizeLog2;
   usage_.external_in_words -= size_in_words;
 }
 
 
+// Provides exclusive access to the pages, and ensures they are walkable.
+class ExclusivePageIterator : ValueObject {
+ public:
+  explicit ExclusivePageIterator(const PageSpace* space)
+      : space_(space), ml_(space->pages_lock_) {
+    space_->MakeIterable();
+    page_ = space_->pages_;
+    if (page_ == NULL) {
+      page_ = space_->exec_pages_;
+      if (page_ == NULL) {
+        page_ = space_->large_pages_;
+      }
+    }
+  }
+  HeapPage* page() const { return page_; }
+  bool done() const { return page_ == NULL; }
+  void Advance() {
+    ASSERT(!done());
+    page_ = space_->NextPageAnySize(page_);
+  }
+ private:
+  const PageSpace* space_;
+  MutexLocker ml_;
+  NoGCScope no_gc;
+  HeapPage* page_;
+};
+
+
+void PageSpace::MakeIterable() const {
+  // TODO(koda): Assert not called from concurrent sweeper task.
+  if (bump_top_ < bump_end_) {
+    FreeListElement::AsElement(bump_top_, bump_end_ - bump_top_);
+  }
+}
+
+
 bool PageSpace::Contains(uword addr) const {
-  MutexLocker ml(pages_lock_);
-  NoGCScope no_gc;
-  HeapPage* page = pages_;
-  while (page != NULL) {
-    if (page->Contains(addr)) {
+  for (ExclusivePageIterator it(this); !it.done(); it.Advance()) {
+    if (it.page()->Contains(addr)) {
       return true;
     }
-    page = NextPageAnySize(page);
   }
   return false;
 }
 
 
 bool PageSpace::Contains(uword addr, HeapPage::PageType type) const {
-  MutexLocker ml(pages_lock_);
-  NoGCScope no_gc;
-  HeapPage* page = pages_;
-  while (page != NULL) {
-    if ((page->type() == type) && page->Contains(addr)) {
+  for (ExclusivePageIterator it(this); !it.done(); it.Advance()) {
+    if ((it.page()->type() == type) && it.page()->Contains(addr)) {
       return true;
     }
-    page = NextPageAnySize(page);
   }
   return false;
 }
 
 
 void PageSpace::StartEndAddress(uword* start, uword* end) const {
-  MutexLocker ml(pages_lock_);
-  NoGCScope no_gc;
   ASSERT((pages_ != NULL) || (exec_pages_ != NULL) || (large_pages_ != NULL));
   *start = static_cast<uword>(~0);
   *end = 0;
-  for (HeapPage* page = pages_; page != NULL; page = NextPageAnySize(page)) {
-    *start = Utils::Minimum(*start, page->object_start());
-    *end = Utils::Maximum(*end, page->object_end());
+  for (ExclusivePageIterator it(this); !it.done(); it.Advance()) {
+    *start = Utils::Minimum(*start, it.page()->object_start());
+    *end = Utils::Maximum(*end, it.page()->object_end());
   }
   ASSERT(*start != static_cast<uword>(~0));
   ASSERT(*end != 0);
 }
 
 
 void PageSpace::VisitObjects(ObjectVisitor* visitor) const {
-  MutexLocker ml(pages_lock_);
-  NoGCScope no_gc;
-  HeapPage* page = pages_;
-  while (page != NULL) {
-    page->VisitObjects(visitor);
-    page = NextPageAnySize(page);
+  for (ExclusivePageIterator it(this); !it.done(); it.Advance()) {
+    it.page()->VisitObjects(visitor);
   }
 }
 
 
 void PageSpace::VisitObjectPointers(ObjectPointerVisitor* visitor) const {
-  MutexLocker ml(pages_lock_);
-  NoGCScope no_gc;
-  HeapPage* page = pages_;
-  while (page != NULL) {
-    page->VisitObjectPointers(visitor);
-    page = NextPageAnySize(page);
+  for (ExclusivePageIterator it(this); !it.done(); it.Advance()) {
+    it.page()->VisitObjectPointers(visitor);
   }
 }
 
 
 RawObject* PageSpace::FindObject(FindObjectVisitor* visitor,
                                  HeapPage::PageType type) const {
-  ASSERT(Isolate::Current()->no_gc_scope_depth() != 0);
-  MutexLocker ml(pages_lock_);
-  NoGCScope no_gc;
-  HeapPage* page = pages_;
-  while (page != NULL) {
-    if (page->type() == type) {
-      RawObject* obj = page->FindObject(visitor);
+  for (ExclusivePageIterator it(this); !it.done(); it.Advance()) {
+    if (it.page()->type() == type) {
+      RawObject* obj = it.page()->FindObject(visitor);
       if (obj != Object::null()) {
         return obj;
       }
     }
-    page = NextPageAnySize(page);
   }
   return Object::null();
 }
 
 
 void PageSpace::WriteProtect(bool read_only) {
-  MutexLocker ml(pages_lock_);
-  NoGCScope no_gc;
-  HeapPage* page = pages_;
-  while (page != NULL) {
-    page->WriteProtect(read_only);
-    page = NextPageAnySize(page);
+  for (ExclusivePageIterator it(this); !it.done(); it.Advance()) {
+    it.page()->WriteProtect(read_only);
   }
 }
 
 
 void PageSpace::PrintToJSONObject(JSONObject* object) {
   Isolate* isolate = Isolate::Current();
   ASSERT(isolate != NULL);
   JSONObject space(object, "old");
   space.AddProperty("type", "HeapSpace");
   space.AddProperty("id", "heaps/old");
@@ skipping 40 matching lines @@
   heap_map.AddProperty("unit_size_bytes",
                        static_cast<intptr_t>(kObjectAlignment));
   heap_map.AddProperty("page_size_bytes", kPageSizeInWords * kWordSize);
   {
     JSONObject class_list(&heap_map, "class_list");
     isolate->class_table()->PrintToJSONObject(&class_list);
   }
   {
     // "pages" is an array [page0, page1, ..., pageN], each page of the form
     // {"object_start": "0x...", "objects": [size, class id, size, ...]}
+    // TODO(19445): Use ExclusivePageIterator once HeapMap supports large pages.
     MutexLocker ml(pages_lock_);
+    MakeIterable();
     NoGCScope no_gc;
     JSONArray all_pages(&heap_map, "pages");
     for (HeapPage* page = pages_; page != NULL; page = page->next()) {
       JSONObject page_container(&all_pages);
       page_container.AddPropertyF("object_start",
                                   "0x%" Px "", page->object_start());
       JSONArray page_map(&page_container, "objects");
       HeapMapAsJSONVisitor printer(&page_map);
       page->VisitObjects(&printer);
     }
@@ skipping 87 matching lines @@
 
   // 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);
   usage_.used_in_words = marker.marked_words();
 
   int64_t mid1 = OS::GetCurrentTimeMicros();
 
   // Abandon the remainder of the bump allocation block.
+  MakeIterable();
   bump_top_ = 0;
   bump_end_ = 0;
   // Reset the freelists and setup sweeping.
   freelist_[HeapPage::kData].Reset();
   freelist_[HeapPage::kExecutable].Reset();
 
   int64_t mid2 = OS::GetCurrentTimeMicros();
   int64_t mid3 = 0;
 
   {
-    GCSweeper sweeper(heap_);
+    GCSweeper sweeper;
 
     // During stop-the-world phases we should use bulk lock when adding elements
     // to the free list.
     MutexLocker mld(freelist_[HeapPage::kData].mutex());
     MutexLocker mle(freelist_[HeapPage::kExecutable].mutex());
 
     // Large and executable pages are always swept immediately.
     HeapPage* prev_page = NULL;
     HeapPage* page = large_pages_;
     while (page != NULL) {
@@ skipping 119 matching lines @@
       }
     }
     bump_top_ = reinterpret_cast<uword>(block);
     bump_end_ = bump_top_ + block_size;
     remaining = block_size;
   }
   ASSERT(remaining >= size);
   uword result = bump_top_;
   bump_top_ += size;
   usage_.used_in_words += size >> kWordSizeLog2;
-  remaining -= size;
-  if (remaining > 0) {
-    FreeListElement::AsElement(bump_top_, remaining);
+  // Note: Remaining block is unwalkable until MakeIterable is called.
+  #ifdef DEBUG
+  if (bump_top_ < bump_end_) {
+    // Fail fast if we try to walk the remaining block.
+    COMPILE_ASSERT(kIllegalCid == 0);
+    *reinterpret_cast<uword*>(bump_top_) = 0;
   }
+  #endif  // DEBUG
   return result;
 }
 
 
 uword PageSpace::TryAllocateDataBump(intptr_t size,
                                      GrowthPolicy growth_policy) {
   return TryAllocateDataBumpInternal(size, growth_policy, false);
 }
 
 
@@ skipping 142 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