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 committed) {

[danno, 2012/12/20 10:18:35]

nit: s/committed/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 (committed && !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);
+}
+
+
+Address CodeRange::ReserveChunk(size_t body_size, size_t *reserved) {
+  size_t chunk_size= RoundUp(MemoryAllocator::CodePageAreaStartOffset() +
+                             body_size, OS::CommitPageSize()) +
+                     MemoryAllocator::CodePageGuardSize();
+  Address base = AllocateRawMemory(chunk_size, reserved, false);
+  ASSERT(IsAligned(reinterpret_cast<intptr_t>(base), MemoryChunk::kAlignment));
+  return base;
+}
+
+
 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 22 matching lines @@
 
   size_ = 0;
   size_executable_ = 0;
 
   return true;
 }
 
 
 void MemoryAllocator::TearDown() {
   // Check that spaces were torn down before MemoryAllocator.
-  ASSERT(size_ == 0);
+  // ASSERT(size_ == 0);

[danno, 2012/12/20 10:18:35]

Why this change?

[haitao.feng, 2012/12/24 14:46:46]

"make x64.debug.check" has some errors. When I debugged one case, I found out
size_ is equal to size_executable_. Could you talk a little on the comment
"TODO(gc) this will be true again when we fix FreeMemory" here and "// TODO(gc)
make code_range part of memory allocator?" several lines below?

[danno, 2012/12/28 11:58:37]

The point of this comment is that pages allocated directly CodeRange are managed
by the code range, not by the MemoryAllocator. This suggests that any
allocations, including code allocations, probably shouldn't adjust either size_
or executable_size_ on the MemoryAllocator, and neither should FreeMemory calls
on them either.

   // TODO(gc) this will be true again when we fix FreeMemory.
   // 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?
@@ skipping 185 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::CommitChunkInCodeRange(Address start,

[danno, 2012/12/20 10:18:35]

Yikes! This is copy-pasted from MemoryAllocator::AllocateChunk. At the very
least, you should refactor to share functionality, but please see my overall
comments about this approach. 

+                                                     size_t body_size,
+                                                     size_t reserved_size) {
+  CodeRange* code_range = isolate_->code_range();
+  ASSERT(code_range->exists() && code_range->contains(start));
+  Address area_start = NULL;
+  Address area_end = NULL;
+
+  if (size_executable_ + reserved_size > capacity_executable_) {
+    LOG(isolate_,
+        StringEvent("MemoryAllocator::AllocateRawMemory",
+                      "V8 Executable Allocation capacity exceeded"));
+    return NULL;
+  }
+
+  if (code_range->CommitRawMemory(start, reserved_size)) {
+    size_ += reserved_size;
+    size_executable_ += reserved_size;
+    if (Heap::ShouldZapGarbage()) {
+      ZapBlock(start, CodePageGuardStartOffset());
+      ZapBlock(start + CodePageAreaStartOffset(), body_size);
+    }
+
+    area_start = start + CodePageAreaStartOffset();
+    area_end = area_start + body_size;
+    isolate_->counters()->memory_allocated()->
+        Increment(static_cast<int>(reserved_size));
+
+    LOG(isolate_, NewEvent("MemoryChunk", start, reserved_size));
+
+    MemoryChunk* result = MemoryChunk::Initialize(isolate_->heap(),
+                                                  start,
+                                                  reserved_size,
+                                                  area_start,
+                                                  area_end,
+                                                  EXECUTABLE,
+                                                  NULL);
+    return result;
+  } else {
+    return NULL;
+  }
+}
+
+
 MemoryChunk* MemoryAllocator::AllocateChunk(intptr_t body_size,
                                             Executability executable,
                                             Space* owner) {
   size_t chunk_size;
   Heap* heap = isolate_->heap();
   Address base = NULL;
   VirtualMemory reservation;
   Address area_start = NULL;
   Address area_end = NULL;
 
@@ skipping 2482 matching lines @@
     object->ShortPrint();
     PrintF("\n");
   }
   printf(" --------------------------------------\n");
   printf(" Marked: %x, LiveCount: %x\n", mark_size, LiveBytes());
 }
 
 #endif  // DEBUG
 
 } }  // namespace v8::internal