- Consolidate code into the old generation.

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/gc_marker.h"
 #include "vm/gc_sweeper.h"
 #include "vm/object.h"
 #include "vm/virtual_memory.h"
 
 namespace dart {
 
 DEFINE_FLAG(int, heap_growth_space_ratio, 10,
             "The desired maximum percentage of free space after GC");
 DEFINE_FLAG(int, heap_growth_time_ratio, 3,
             "The desired maximum percentage of time spent in GC");
 DEFINE_FLAG(int, heap_growth_rate, 4,
             "The size the heap is grown, in heap pages");
 DEFINE_FLAG(bool, print_free_list_before_gc, false,
             "Print free list statistics before a GC");
 DEFINE_FLAG(bool, print_free_list_after_gc, false,
             "Print free list statistics after a GC");
 
-HeapPage* HeapPage::Initialize(VirtualMemory* memory, bool is_executable) {
+HeapPage* HeapPage::Initialize(VirtualMemory* memory, PageType type) {
   ASSERT(memory->size() > VirtualMemory::PageSize());
+  bool is_executable = (type == kExecutable);
   memory->Commit(is_executable);
 
   HeapPage* result = reinterpret_cast<HeapPage*>(memory->address());
   result->memory_ = memory;
   result->next_ = NULL;
   result->used_ = 0;
+  result->executable_ = is_executable;
   return result;
 }
 
 
-HeapPage* HeapPage::Allocate(intptr_t size, bool is_executable) {
+HeapPage* HeapPage::Allocate(intptr_t size, PageType type) {
   VirtualMemory* memory =
       VirtualMemory::ReserveAligned(size, PageSpace::kPageAlignment);
-  return Initialize(memory, is_executable);
+  return Initialize(memory, type);
 }
 
 
 void HeapPage::Deallocate() {
   // The memory for this object will become unavailable after the delete below.
   delete memory_;
 }
 
 
 void HeapPage::VisitObjects(ObjectVisitor* visitor) const {
@@ skipping 28 matching lines @@
       return raw_obj;  // Found object, return it.
     }
     obj_addr += raw_obj->Size();
   }
   ASSERT(obj_addr == end_addr);
   return Object::null();
 }
 
 
 void HeapPage::WriteProtect(bool read_only) {
-  memory_->Protect(
-      read_only ? VirtualMemory::kReadOnly : VirtualMemory::kReadWrite);
+  VirtualMemory::Protection prot;
+  if (read_only) {
+    if (executable_) {
+      prot = VirtualMemory::kReadExecute;
+    } else {
+      prot = VirtualMemory::kReadOnly;
+    }
+  } else {
+    if (executable_) {
+      prot = VirtualMemory::kReadWriteExecute;
+    } else {
+      prot = VirtualMemory::kReadWrite;
+    }
+  }
+  memory_->Protect(prot);
 }
 
 
-PageSpace::PageSpace(Heap* heap, intptr_t max_capacity, bool is_executable)
+PageSpace::PageSpace(Heap* heap, intptr_t max_capacity)
     : freelist_(),
       heap_(heap),
       pages_(NULL),
       pages_tail_(NULL),
       large_pages_(NULL),
       max_capacity_(max_capacity),
       capacity_(0),
       in_use_(0),
       count_(0),
-      is_executable_(is_executable),
       sweeping_(false),
       page_space_controller_(FLAG_heap_growth_space_ratio,
                              FLAG_heap_growth_rate,
                              FLAG_heap_growth_time_ratio) {
 }
 
 
 PageSpace::~PageSpace() {
   FreePages(pages_);
   FreePages(large_pages_);
 }
 
 
 intptr_t PageSpace::LargePageSizeFor(intptr_t size) {
   intptr_t page_size = Utils::RoundUp(size + sizeof(HeapPage),
                                       VirtualMemory::PageSize());
   return page_size;
 }
 
 
-HeapPage* PageSpace::AllocatePage() {
-  HeapPage* page = HeapPage::Allocate(kPageSize, is_executable_);
+HeapPage* PageSpace::AllocatePage(HeapPage::PageType type) {
+  HeapPage* page = HeapPage::Allocate(kPageSize, type);
   if (pages_ == NULL) {
     pages_ = page;
   } else {
     pages_tail_->set_next(page);
   }
   pages_tail_ = page;
   capacity_ += kPageSize;
   page->set_object_end(page->memory_->end());
   return page;
 }
 
 
-HeapPage* PageSpace::AllocateLargePage(intptr_t size) {
+HeapPage* PageSpace::AllocateLargePage(intptr_t size, HeapPage::PageType type) {
   intptr_t page_size = LargePageSizeFor(size);
-  HeapPage* page = HeapPage::Allocate(page_size, is_executable_);
+  HeapPage* page = HeapPage::Allocate(page_size, type);
   page->set_next(large_pages_);
   large_pages_ = page;
   capacity_ += page_size;
   // Only one object in this page.
   page->set_object_end(page->object_start() + size);
   return page;
 }
 
 
 void PageSpace::FreePage(HeapPage* page, HeapPage* previous_page) {
@@ skipping 27 matching lines @@
 void PageSpace::FreePages(HeapPage* pages) {
   HeapPage* page = pages;
   while (page != NULL) {
     HeapPage* next = page->next();
     page->Deallocate();
     page = next;
   }
 }
 
 
-uword PageSpace::TryAllocate(intptr_t size) {
-  return TryAllocate(size, kControlGrowth);
-}
-
-
-uword PageSpace::TryAllocate(intptr_t size, GrowthPolicy growth_policy) {
+uword PageSpace::TryAllocate(intptr_t size,
+                             HeapPage::PageType type,
+                             GrowthPolicy growth_policy) {
   ASSERT(size >= kObjectAlignment);
   ASSERT(Utils::IsAligned(size, kObjectAlignment));
   uword result = 0;
   if (size < kAllocatablePageSize) {
-    result = freelist_.TryAllocate(size);
+    result = freelist_[type].TryAllocate(size);
     if ((result == 0) &&
         (page_space_controller_.CanGrowPageSpace(size) ||
          growth_policy == kForceGrowth) &&
         CanIncreaseCapacity(kPageSize)) {
-      HeapPage* page = AllocatePage();
+      HeapPage* page = AllocatePage(type);
       ASSERT(page != NULL);
       // Start of the newly allocated page is the allocated object.
       result = page->object_start();
       // Enqueue the remainder in the free list.
       uword free_start = result + size;
-      freelist_.Free(free_start, page->object_end() - free_start);
+      freelist_[type].Free(free_start, page->object_end() - free_start);
     }
   } else {
     // Large page allocation.
     intptr_t page_size = LargePageSizeFor(size);
     if (page_size < size) {
       // On overflow we fail to allocate.
       return 0;
     }
     if (CanIncreaseCapacity(page_size)) {
-      HeapPage* page = AllocateLargePage(size);
+      HeapPage* page = AllocateLargePage(size, type);
       if (page != NULL) {
         result = page->object_start();
       }
     }
   }
   if (result != 0) {
     in_use_ += size;
   }
   ASSERT((result & kObjectAlignmentMask) == kOldObjectAlignmentOffset);
   return result;
@@ skipping 13 matching lines @@
   while (page != NULL) {
     if (page->Contains(addr)) {
       return true;
     }
     page = page->next();
   }
   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();
+  }
+  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()) {
     *start = Utils::Minimum(*start, page->object_start());
@@ skipping 47 matching lines @@
   }
 
   page = large_pages_;
   while (page != NULL) {
     page->VisitObjectPointers(visitor);
     page = page->next();
   }
 }
 
 
-RawObject* PageSpace::FindObject(FindObjectVisitor* visitor) const {
+RawObject* PageSpace::FindObject(FindObjectVisitor* visitor,
+                                 HeapPage::PageType type) const {
   ASSERT(Isolate::Current()->no_gc_scope_depth() != 0);
   HeapPage* page = pages_;
   while (page != NULL) {
-    RawObject* obj = page->FindObject(visitor);
-    if (obj != Object::null()) {
-      return obj;
+    if (page->type() == type) {
+      RawObject* obj = page->FindObject(visitor);
+      if (obj != Object::null()) {
+        return obj;
+      }
     }
     page = page->next();
   }
 
   page = large_pages_;
   while (page != NULL) {
-    RawObject* obj = page->FindObject(visitor);
-    if (obj != Object::null()) {
-      return obj;
+    if (page->type() == type) {
+      RawObject* obj = page->FindObject(visitor);
+      if (obj != Object::null()) {
+        return obj;
+      }
     }
     page = page->next();
   }
   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();
   }
 }
 
 
 void PageSpace::MarkSweep(bool invoke_api_callbacks, const char* gc_reason) {
   // MarkSweep is not reentrant. Make sure that is the case.
   ASSERT(!sweeping_);
   sweeping_ = true;
   Isolate* isolate = Isolate::Current();
   NoHandleScope no_handles(isolate);
 
   if (FLAG_print_free_list_before_gc) {
-    freelist_.Print();
+    OS::Print("Data Freelist:\n");
+    freelist_[HeapPage::kData].Print();
+    OS::Print("Executable Freelist:\n");
+    freelist_[HeapPage::kExecutable].Print();
   }
 
   if (FLAG_verify_before_gc) {
     OS::PrintErr("Verifying before MarkSweep...");
     heap_->Verify();
     OS::PrintErr(" done.\n");
   }
 
   if (FLAG_verbose_gc) {
     OS::PrintErr("Start mark sweep for %s collection\n", gc_reason);
   }
   Timer timer(true, "MarkSweep");
   timer.Start();
   int64_t start = OS::GetCurrentTimeMillis();
 
   // Mark all reachable old-gen objects.
   GCMarker marker(heap_);
   marker.MarkObjects(isolate, this, invoke_api_callbacks);
 
   // Reset the bump allocation page to unused.
   // Reset the freelists and setup sweeping.
-  freelist_.Reset();
+  freelist_[HeapPage::kData].Reset();
+  freelist_[HeapPage::kExecutable].Reset();
   GCSweeper sweeper(heap_);
   intptr_t in_use = 0;
 
   HeapPage* prev_page = NULL;
   HeapPage* page = pages_;
   while (page != NULL) {
-    intptr_t page_in_use = sweeper.SweepPage(page, &freelist_);
     HeapPage* next_page = page->next();
+    intptr_t page_in_use = sweeper.SweepPage(page, &freelist_[page->type()]);
     if (page_in_use == 0) {
       FreePage(page, prev_page);
     } else {
       in_use += page_in_use;
       prev_page = page;
     }
     // Advance to the next page.
     page = next_page;
   }
 
@@ skipping 27 matching lines @@
     const intptr_t KB2 = KB / 2;
     OS::PrintErr("Mark-Sweep[%d]: %"Pd64"us (%"Pd"K -> %"Pd"K, %"Pd"K)\n",
                  count_,
                  timer.TotalElapsedTime(),
                  (in_use_before + (KB2)) / KB,
                  (in_use + (KB2)) / KB,
                  (capacity_ + KB2) / KB);
   }
 
   if (FLAG_print_free_list_after_gc) {
-    freelist_.Print();
+    OS::Print("Data Freelist:\n");
+    freelist_[HeapPage::kData].Print();
+    OS::Print("Executable Freelist:\n");
+    freelist_[HeapPage::kExecutable].Print();
   }
 
   if (FLAG_verify_after_gc) {
     OS::PrintErr("Verifying after MarkSweep...");
     heap_->Verify();
     OS::PrintErr(" done.\n");
   }
 
   count_++;
   // Done, reset the marker.
@@ skipping 120 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