Move aligned allocation to the platform files.

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 274 matching lines @@
   ASSERT_GE(capacity_, capacity_executable_);
 
   size_ = 0;
   size_executable_ = 0;
 
   return true;
 }
 
 
 void MemoryAllocator::TearDown() {
-  // Check that spaces were teared down before MemoryAllocator.
+  // 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);
   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();
+  ASSERT(size_ >= size);
+  size_ -= size;
+
+  isolate_->counters()->memory_allocated()->Decrement(static_cast<int>(size));
+
+  if (executable == EXECUTABLE) {
+    ASSERT(size_executable_ >= size);
+    size_executable_ -= size;
+  }
+  // Code which is part of the code-range does not have its own VirtualMemory.
+  ASSERT(!isolate_->code_range()->contains(
+      static_cast<Address>(reservation->address())));
+  ASSERT(executable == NOT_EXECUTABLE || !isolate_->code_range()->exists());
+  reservation->Release();
+}
+
+
 void MemoryAllocator::FreeMemory(Address base,
                                  size_t size,
                                  Executability executable) {
   // TODO(gc) make code_range part of memory allocator?
   ASSERT(size_ >= size);
   size_ -= size;
 
   isolate_->counters()->memory_allocated()->Decrement(static_cast<int>(size));
 
   if (executable == EXECUTABLE) {
     ASSERT(size_executable_ >= size);
     size_executable_ -= size;
   }
   if (isolate_->code_range()->contains(static_cast<Address>(base))) {
     ASSERT(executable == EXECUTABLE);
     isolate_->code_range()->FreeRawMemory(base, size);
   } else {
     ASSERT(executable == NOT_EXECUTABLE || !isolate_->code_range()->exists());
     VirtualMemory::ReleaseRegion(base, size);
   }
 }
 
 
-Address MemoryAllocator::ReserveAlignedMemory(const size_t requested,
+Address MemoryAllocator::ReserveAlignedMemory(size_t size,
                                               size_t alignment,
-                                              size_t* allocated_size) {
-  ASSERT(IsAligned(alignment, OS::AllocateAlignment()));
-  if (size_ + requested > capacity_) return NULL;
+                                              VirtualMemory* controller) {
+  VirtualMemory reservation(size, alignment);
 
-  size_t allocated = RoundUp(requested + alignment,
-                             static_cast<intptr_t>(OS::AllocateAlignment()));
-
-  Address base = reinterpret_cast<Address>(
-      VirtualMemory::ReserveRegion(allocated));
-
-  Address end = base + allocated;
-
-  if (base == 0) return NULL;
-
-  Address aligned_base = RoundUp(base, alignment);
-
-  ASSERT(aligned_base + requested <= base + allocated);
-
-  // The difference between re-aligned base address and base address is
-  // multiple of OS::AllocateAlignment().
-  if (aligned_base != base) {
-    ASSERT(aligned_base > base);
-    // TODO(gc) check result of operation?
-    VirtualMemory::ReleaseRegion(reinterpret_cast<void*>(base),
-                                 aligned_base - base);
-    allocated -= (aligned_base - base);
-    base = aligned_base;
-  }
-
-  ASSERT(base + allocated == end);
-
-  Address requested_end = base + requested;
-  Address aligned_requested_end =
-      RoundUp(requested_end, OS::AllocateAlignment());
-
-  if (aligned_requested_end < end) {
-    // TODO(gc) check result of operation?
-    VirtualMemory::ReleaseRegion(reinterpret_cast<void*>(aligned_requested_end),
-                                 end - aligned_requested_end);
-    allocated = aligned_requested_end - base;
-  }
-
-  size_ += allocated;
-  *allocated_size = allocated;
+  if (!reservation.IsReserved()) return NULL;
+  size_ += reservation.size();
+  Address base = RoundUp(static_cast<Address>(reservation.address()),
+                         alignment);
+  controller->TakeControl(&reservation);
   return base;
 }
 
 
-Address MemoryAllocator::AllocateAlignedMemory(const size_t requested,
+Address MemoryAllocator::AllocateAlignedMemory(size_t size,
                                                size_t alignment,
                                                Executability executable,
-                                               size_t* allocated_size) {
-  Address base =
-      ReserveAlignedMemory(requested, Page::kPageSize, allocated_size);
-
+                                               VirtualMemory* controller) {
+  VirtualMemory reservation;
+  Address base = ReserveAlignedMemory(size, alignment, &reservation);
   if (base == NULL) return NULL;
-
-  if (!VirtualMemory::CommitRegion(base,
-                                   *allocated_size,
-                                   executable == EXECUTABLE)) {
-    VirtualMemory::ReleaseRegion(base, *allocated_size);
-    size_ -= *allocated_size;
+  if (!reservation.Commit(base,
+                          size,
+                          executable == EXECUTABLE)) {
     return NULL;
   }
-
+  controller->TakeControl(&reservation);
   return base;
 }
 
 
 void Page::InitializeAsAnchor(PagedSpace* owner) {
   set_owner(owner);
   set_prev_page(this);
   set_next_page(this);
 }
 
@@ skipping 36 matching lines @@
                                      Executability executable,
                                      Space* owner) {
   MemoryChunk* chunk = FromAddress(base);
 
   ASSERT(base == chunk->address());
 
   chunk->heap_ = heap;
   chunk->size_ = size;
   chunk->flags_ = 0;
   chunk->set_owner(owner);
+  chunk->InitializeReservedMemory();
   chunk->slots_buffer_ = NULL;
   Bitmap::Clear(chunk);
   chunk->initialize_scan_on_scavenge(false);
   chunk->SetFlag(WAS_SWEPT_PRECISELY);
 
   ASSERT(OFFSET_OF(MemoryChunk, flags_) == kFlagsOffset);
 
   if (executable == EXECUTABLE) chunk->SetFlag(IS_EXECUTABLE);
 
   if (owner == heap->old_data_space()) chunk->SetFlag(CONTAINS_ONLY_DATA);
@@ skipping 21 matching lines @@
   next_chunk_ = NULL;
 }
 
 
 MemoryChunk* MemoryAllocator::AllocateChunk(intptr_t body_size,
                                             Executability executable,
                                             Space* owner) {
   size_t chunk_size = MemoryChunk::kObjectStartOffset + body_size;
   Heap* heap = isolate_->heap();
   Address base = NULL;
+  VirtualMemory reservation;
   if (executable == EXECUTABLE) {
     // 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,
-                                   &chunk_size);
+                                   &reservation);
+      if (base == NULL) return NULL;
+      // Update executable memory size.
+      size_executable_ += reservation.size();
     }
-
-    if (base == NULL) return NULL;
-
-    // Update executable memory size.
-    size_executable_ += chunk_size;
   } else {
     base = AllocateAlignedMemory(chunk_size,
                                  MemoryChunk::kAlignment,
                                  executable,
-                                 &chunk_size);
+                                 &reservation);
 
     if (base == NULL) return NULL;
   }
 
 #ifdef DEBUG
   ZapBlock(base, chunk_size);
 #endif
   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);
   }
 
-  return MemoryChunk::Initialize(heap,
-                                 base,
-                                 chunk_size,
-                                 executable,
-                                 owner);
+  MemoryChunk* result = MemoryChunk::Initialize(heap,
+                                                base,
+                                                chunk_size,
+                                                executable,
+                                                owner);
+  result->set_reserved_memory(&reservation);
+  return result;
 }
 
 
 Page* MemoryAllocator::AllocatePage(PagedSpace* owner,
                                     Executability executable) {
   MemoryChunk* chunk = AllocateChunk(Page::kObjectAreaSize, executable, owner);
 
   if (chunk == NULL) return NULL;
 
   return Page::Initialize(isolate_->heap(), chunk, executable, owner);
@@ skipping 10 matching lines @@
 
 
 void MemoryAllocator::Free(MemoryChunk* chunk) {
   LOG(isolate_, DeleteEvent("MemoryChunk", chunk));
   if (chunk->owner() != NULL) {
     ObjectSpace space =
         static_cast<ObjectSpace>(1 << chunk->owner()->identity());
     PerformAllocationCallback(space, kAllocationActionFree, chunk->size());
   }
 
-  FreeMemory(chunk->address(),
-             chunk->size(),
-             chunk->executable());
+  VirtualMemory* reservation = chunk->reserved_memory();
+  if (reservation->IsReserved()) {
+    FreeMemory(reservation, chunk->executable());
+  } else {
+    FreeMemory(chunk->address(),
+               chunk->size(),
+               chunk->executable());
+  }
 }
 
 
 bool MemoryAllocator::CommitBlock(Address start,
                                   size_t size,
                                   Executability executable) {
   if (!VirtualMemory::CommitRegion(start, size, executable)) return false;
 #ifdef DEBUG
   ZapBlock(start, size);
 #endif
@@ skipping 251 matching lines @@
 
 
 bool NewSpace::Setup(int reserved_semispace_capacity,
                      int maximum_semispace_capacity) {
   // Setup 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 = 0;
+  size_t size = 2 * reserved_semispace_capacity;
   Address base =
       heap()->isolate()->memory_allocator()->ReserveAlignedMemory(
-          2 * reserved_semispace_capacity,
-          2 * reserved_semispace_capacity,
-          &size);
-
+          size, size, &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 setup the histogram arrays if necessary.
@@ skipping 43 matching lines @@
   }
 
   start_ = NULL;
   allocation_info_.top = NULL;
   allocation_info_.limit = NULL;
 
   to_space_.TearDown();
   from_space_.TearDown();
 
   LOG(heap()->isolate(), DeleteEvent("InitialChunk", chunk_base_));
-  heap()->isolate()->memory_allocator()->FreeMemory(
-      chunk_base_,
-      static_cast<size_t>(chunk_size_),
-      NOT_EXECUTABLE);
+
+  ASSERT(reservation_.IsReserved());
+  heap()->isolate()->memory_allocator()->FreeMemory(&reservation_,
+                                                    NOT_EXECUTABLE);
   chunk_base_ = NULL;
   chunk_size_ = 0;
 }
 
 
 void NewSpace::Flip() {
   SemiSpace::Swap(&from_space_, &to_space_);
 }
 
 
@@ skipping 1575 matching lines @@
   for (HeapObject* obj = obj_it.Next(); obj != NULL; obj = obj_it.Next()) {
     if (obj->IsCode()) {
       Code* code = Code::cast(obj);
       isolate->code_kind_statistics()[code->kind()] += code->Size();
     }
   }
 }
 #endif  // DEBUG
 
 } }  // namespace v8::internal