Use MemoryChunk-based allocation for deoptimization entry code

src/spaces.cc

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 189 matching lines @@
     if (requested <= allocation_list_[current_allocation_block_index_].size) {
       return;  // Found a large enough allocation block.
     }
   }
 
   // Code range is full or too fragmented.
   V8::FatalProcessOutOfMemory("CodeRange::GetNextAllocationBlock");
 }
 
 
-
 Address CodeRange::AllocateRawMemory(const size_t requested,
-                                     size_t* allocated) {
+                                     size_t* allocated,
+                                     bool commit) {
   ASSERT(current_allocation_block_index_ < allocation_list_.length());
   if (requested > allocation_list_[current_allocation_block_index_].size) {
     // Find an allocation block large enough.  This function call may
     // call V8::FatalProcessOutOfMemory if it cannot find a large enough block.
     GetNextAllocationBlock(requested);
   }
   // Commit the requested memory at the start of the current allocation block.
   size_t aligned_requested = RoundUp(requested, MemoryChunk::kAlignment);
   FreeBlock current = allocation_list_[current_allocation_block_index_];
   if (aligned_requested >= (current.size - Page::kPageSize)) {
     // Don't leave a small free block, useless for a large object or chunk.
     *allocated = current.size;
   } else {
     *allocated = aligned_requested;
   }
   ASSERT(*allocated <= current.size);
   ASSERT(IsAddressAligned(current.start, MemoryChunk::kAlignment));
-  if (!MemoryAllocator::CommitCodePage(code_range_,
-                                       current.start,
-                                       *allocated)) {
+  if (commit && !CommitRawMemory(current.start, *allocated)) {
     *allocated = 0;
     return NULL;
   }
   allocation_list_[current_allocation_block_index_].start += *allocated;
   allocation_list_[current_allocation_block_index_].size -= *allocated;
   if (*allocated == current.size) {
     GetNextAllocationBlock(0);  // This block is used up, get the next one.
   }
   return current.start;
 }
 
 
+bool CodeRange::CommitRawMemory(Address start, size_t size) {
+  return MemoryAllocator::CommitCodePage(code_range_, start, size);
+}
+
+
 void CodeRange::FreeRawMemory(Address address, size_t length) {
   ASSERT(IsAddressAligned(address, MemoryChunk::kAlignment));
   free_list_.Add(FreeBlock(address, length));
   code_range_->Uncommit(address, length);
 }
 
 
 void CodeRange::TearDown() {
     delete code_range_;  // Frees all memory in the virtual memory range.
     code_range_ = NULL;
@@ skipping 23 matching lines @@
   size_ = 0;
   size_executable_ = 0;
 
   return true;
 }
 
 
 void MemoryAllocator::TearDown() {
   // Check that spaces were torn down before MemoryAllocator.
   ASSERT(size_ == 0);
-  // TODO(gc) this will be true again when we fix FreeMemory.
-  // ASSERT(size_executable_ == 0);
+  ASSERT(size_executable_ == 0);
   capacity_ = 0;
   capacity_executable_ = 0;
 }
 
 
 void MemoryAllocator::FreeMemory(VirtualMemory* reservation,
                                  Executability executable) {
   // TODO(gc) make code_range part of memory allocator?
   ASSERT(reservation->IsReserved());
   size_t size = reservation->size();
@@ skipping 32 matching lines @@
     isolate_->code_range()->FreeRawMemory(base, size);
   } else {
     ASSERT(executable == NOT_EXECUTABLE || !isolate_->code_range()->exists());
     bool result = VirtualMemory::ReleaseRegion(base, size);
     USE(result);
     ASSERT(result);
   }
 }
 
 
-Address MemoryAllocator::ReserveAlignedMemory(size_t size,
+Address MemoryAllocator::ReserveAlignedMemory(size_t requested,
                                               size_t alignment,
+                                              Executability executable,
                                               VirtualMemory* controller) {
-  VirtualMemory reservation(size, alignment);
+  VirtualMemory reservation(requested, alignment);
+  if (!reservation.IsReserved()) return NULL;
 
-  if (!reservation.IsReserved()) return NULL;
+  Address base = static_cast<Address>(reservation.address());
   size_ += reservation.size();
-  Address base = RoundUp(static_cast<Address>(reservation.address()),
-                         alignment);
+  if (executable == EXECUTABLE) {

[danno, 2013/01/15 09:41:18]

It seems that you've removed the logic that rounds the base address up? That
doesn't seem right.

[haitao.feng, 2013/01/16 13:02:06]

This RoundUp is done in the reservation(requested, alignment) in each platform.
So we do not need to do it here again.

+    size_executable_ += reservation.size();
+  }
+
   controller->TakeControl(&reservation);
   return base;
 }
 
 
-Address MemoryAllocator::AllocateAlignedMemory(size_t size,
-                                               size_t alignment,
-                                               Executability executable,
-                                               VirtualMemory* controller) {
-  VirtualMemory reservation;
-  Address base = ReserveAlignedMemory(size, alignment, &reservation);
+Address MemoryAllocator::CommitAlignedMemory(VirtualMemory* reservation,
+                                             Executability executable) {
+  Address base = static_cast<Address>(reservation->address());
   if (base == NULL) return NULL;
 
+  size_t size = reservation->size();
+
   if (executable == EXECUTABLE) {
-    if (!CommitCodePage(&reservation, base, size)) {
+    if (!CommitCodePage(reservation, base, size)) {
       base = NULL;
     }
   } else {
-    if (!reservation.Commit(base, size, false)) {
+    if (!reservation->Commit(base, size, false)) {
       base = NULL;
     }
   }
 
   if (base == NULL) {
     // Failed to commit the body. Release the mapping and any partially
     // commited regions inside it.
-    reservation.Release();
+    reservation->Release();
     return NULL;
   }
 
+  return base;
+}
+
+
+Address MemoryAllocator::AllocateAlignedMemory(size_t size,
+                                               size_t alignment,
+                                               Executability executable,
+                                               VirtualMemory* controller) {
+  VirtualMemory reservation;
+  Address base = ReserveAlignedMemory(size,
+                                      alignment,
+                                      executable,
+                                      &reservation);
+  base = CommitAlignedMemory(&reservation, executable);
   controller->TakeControl(&reservation);
   return base;
 }
 
 
 void Page::InitializeAsAnchor(PagedSpace* owner) {
   set_owner(owner);
   set_prev_page(this);
   set_next_page(this);
 }
@@ skipping 92 matching lines @@
     heap_->decrement_scan_on_scavenge_pages();
     ClearFlag(SCAN_ON_SCAVENGE);
   }
   next_chunk_->prev_chunk_ = prev_chunk_;
   prev_chunk_->next_chunk_ = next_chunk_;
   prev_chunk_ = NULL;
   next_chunk_ = NULL;
 }
 
 
-MemoryChunk* MemoryAllocator::AllocateChunk(intptr_t body_size,
-                                            Executability executable,
-                                            Space* owner) {
+Address MemoryAllocator::ReserveChunk(size_t body_size,
+                                      Executability executable,
+                                      VirtualMemory* controller) {
   size_t chunk_size;
-  Heap* heap = isolate_->heap();
   Address base = NULL;
   VirtualMemory reservation;
-  Address area_start = NULL;
-  Address area_end = NULL;
 
   if (executable == EXECUTABLE) {
     chunk_size = RoundUp(CodePageAreaStartOffset() + body_size,
                          OS::CommitPageSize()) + CodePageGuardSize();
 
     // Check executable memory limit.
     if (size_executable_ + chunk_size > capacity_executable_) {
       LOG(isolate_,
           StringEvent("MemoryAllocator::AllocateRawMemory",
                       "V8 Executable Allocation capacity exceeded"));
       return NULL;
     }
 
-    // Allocate executable memory either from code range or from the
-    // OS.
-    if (isolate_->code_range()->exists()) {
-      base = isolate_->code_range()->AllocateRawMemory(chunk_size, &chunk_size);
-      ASSERT(IsAligned(reinterpret_cast<intptr_t>(base),
-                       MemoryChunk::kAlignment));
-      if (base == NULL) return NULL;
-      size_ += chunk_size;
-      // Update executable memory size.
-      size_executable_ += chunk_size;
-    } else {
-      base = AllocateAlignedMemory(chunk_size,
-                                   MemoryChunk::kAlignment,
-                                   executable,
-                                   &reservation);
-      if (base == NULL) return NULL;
-      // Update executable memory size.
-      size_executable_ += reservation.size();
-    }
-
-    if (Heap::ShouldZapGarbage()) {
-      ZapBlock(base, CodePageGuardStartOffset());
-      ZapBlock(base + CodePageAreaStartOffset(), body_size);
-    }
-
-    area_start = base + CodePageAreaStartOffset();
-    area_end = area_start + body_size;
+    // Reserve executable chunk from the OS.
+    base = ReserveAlignedMemory(chunk_size,
+                                MemoryChunk::kAlignment,
+                                EXECUTABLE,
+                                &reservation);
   } else {
     chunk_size = MemoryChunk::kObjectStartOffset + body_size;
-    base = AllocateAlignedMemory(chunk_size,
-                                 MemoryChunk::kAlignment,
-                                 executable,
-                                 &reservation);
-
-    if (base == NULL) return NULL;
-
-    if (Heap::ShouldZapGarbage()) {
-      ZapBlock(base, chunk_size);
-    }
-
-    area_start = base + Page::kObjectStartOffset;
-    area_end = base + chunk_size;
+    base = ReserveAlignedMemory(chunk_size,

[danno, 2013/01/15 09:41:18]

Please move the Reserve call after the if {} else {}. Since chunk_size will be
correct after the if/else, then you simply call

ReserveAlignedMemory(chunk_size,  MemoryChunk::kAlignment executable,
&reservation);

+                                MemoryChunk::kAlignment,
+                                NOT_EXECUTABLE,
+                                &reservation);
   }
 
+  controller->TakeControl(&reservation);
+  return base;
+}
+
+
+Address MemoryAllocator::ReserveChunk(size_t body_size, size_t* reserved) {
+  // Reserve chunk from the code range.
+  ASSERT(isolate_->code_range()->exists());
+  size_t chunk_size = RoundUp(CodePageAreaStartOffset() + body_size,
+                              OS::CommitPageSize()) + CodePageGuardSize();
+  Address base = isolate_->code_range()->AllocateRawMemory(chunk_size,
+                                                           reserved,
+                                                           false);
+  ASSERT(IsAligned(reinterpret_cast<intptr_t>(base), MemoryChunk::kAlignment));
+  size_ += *reserved;
+  size_executable_ += *reserved;
+  return base;
+}
+
+
+MemoryChunk* MemoryAllocator::CommitChunkShared(Heap* heap,
+                                                Address base,
+                                                size_t chunk_size,
+                                                Address area_start,
+                                                Address area_end,
+                                                Executability executable,
+                                                Space* owner,
+                                                VirtualMemory* reservation) {
   isolate_->counters()->memory_allocated()->
       Increment(static_cast<int>(chunk_size));
 
   LOG(isolate_, NewEvent("MemoryChunk", base, chunk_size));
   if (owner != NULL) {
     ObjectSpace space = static_cast<ObjectSpace>(1 << owner->identity());
     PerformAllocationCallback(space, kAllocationActionAllocate, chunk_size);
   }
 
   MemoryChunk* result = MemoryChunk::Initialize(heap,
                                                 base,
                                                 chunk_size,
                                                 area_start,
                                                 area_end,
                                                 executable,
                                                 owner);
-  result->set_reserved_memory(&reservation);
+  result->set_reserved_memory(reservation);
   return result;
 }
 
 
+MemoryChunk* MemoryAllocator::CommitChunk(size_t body_size,
+                                          Executability executable,
+                                          VirtualMemory* reservation,
+                                          Space* owner) {
+  Address base = CommitAlignedMemory(reservation, executable);
+  if (base == NULL) return NULL;
+
+  size_t chunk_size = reservation->size();
+  Address area_start = NULL;
+  Address area_end = NULL;
+  Heap* heap = isolate_->heap();
+
+  if (executable == EXECUTABLE) {
+    if (Heap::ShouldZapGarbage()) {
+      ZapBlock(base, CodePageGuardStartOffset());
+      ZapBlock(base + CodePageAreaStartOffset(), body_size);
+    }
+
+    area_start = base + CodePageAreaStartOffset();
+    area_end = area_start + body_size;
+  } else {
+    if (Heap::ShouldZapGarbage()) {
+      ZapBlock(base, chunk_size);
+    }
+
+    area_start = base + Page::kObjectStartOffset;
+    area_end = base + chunk_size;
+  }
+
+  return CommitChunkShared(heap,
+                           base,
+                           chunk_size,
+                           area_start,
+                           area_end,
+                           executable,
+                           owner,
+                           reservation);
+}
+
+
+MemoryChunk* MemoryAllocator::CommitChunk(size_t body_size,
+                                          Address base,
+                                          size_t chunk_size,
+                                          Space* owner) {
+  ASSERT(isolate_->code_range()->exists());
+  if (base == NULL) return NULL;
+
+  if (!isolate_->code_range()->CommitRawMemory(base, chunk_size)) {
+    return NULL;
+  }
+
+  Address area_start = NULL;
+  Address area_end = NULL;
+  Heap* heap = isolate_->heap();
+  VirtualMemory empty;
+
+  if (Heap::ShouldZapGarbage()) {
+    ZapBlock(base, CodePageGuardStartOffset());
+    ZapBlock(base + CodePageAreaStartOffset(), body_size);
+  }
+
+  area_start = base + CodePageAreaStartOffset();
+  area_end = area_start + body_size;
+
+  return CommitChunkShared(heap,
+                           base,
+                           chunk_size,
+                           area_start,
+                           area_end,
+                           EXECUTABLE,
+                           owner,
+                           &empty);
+}
+
+
+MemoryChunk* MemoryAllocator::AllocateChunk(intptr_t body_size,
+                                            Executability executable,
+                                            Space* owner) {
+  if ((executable == EXECUTABLE) && isolate_->code_range()->exists()) {
+    size_t chunk_size;
+    Address base = ReserveChunk(body_size, &chunk_size);
+    return CommitChunk(body_size, base, chunk_size, owner);
+  } else {
+    VirtualMemory reservation;
+    Address base = ReserveChunk(body_size, executable, &reservation);
+    if (base == NULL) return NULL;
+    return CommitChunk(body_size, executable, &reservation, owner);
+  }
+}
+
+
 Page* MemoryAllocator::AllocatePage(intptr_t size,
                                     PagedSpace* owner,
                                     Executability executable) {
   MemoryChunk* chunk = AllocateChunk(size, executable, owner);
 
   if (chunk == NULL) return NULL;
 
   return Page::Initialize(isolate_->heap(), chunk, executable, owner);
 }
 
@@ skipping 471 matching lines @@
                      int maximum_semispace_capacity) {
   // Set up new space based on the preallocated memory block defined by
   // start and size. The provided space is divided into two semi-spaces.
   // To support fast containment testing in the new space, the size of
   // this chunk must be a power of two and it must be aligned to its size.
   int initial_semispace_capacity = heap()->InitialSemiSpaceSize();
 
   size_t size = 2 * reserved_semispace_capacity;
   Address base =
       heap()->isolate()->memory_allocator()->ReserveAlignedMemory(
-          size, size, &reservation_);
+          size, size, NOT_EXECUTABLE, &reservation_);
   if (base == NULL) return false;
 
   chunk_base_ = base;
   chunk_size_ = static_cast<uintptr_t>(size);
   LOG(heap()->isolate(), NewEvent("InitialChunk", chunk_base_, chunk_size_));
 
   ASSERT(initial_semispace_capacity <= maximum_semispace_capacity);
   ASSERT(IsPowerOf2(maximum_semispace_capacity));
 
   // Allocate and set up the histogram arrays if necessary.
@@ skipping 1904 matching lines @@
     object->ShortPrint();
     PrintF("\n");
   }
   printf(" --------------------------------------\n");
   printf(" Marked: %x, LiveCount: %x\n", mark_size, LiveBytes());
 }
 
 #endif  // DEBUG
 
 } }  // namespace v8::internal