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 306 matching lines @@
   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,
-                                              size_t alignment,
-                                              size_t* allocated_size) {
+Address MemoryAllocator::ReserveAlignedMemory(const size_t size,
+                                              size_t alignment) {
   ASSERT(IsAligned(alignment, OS::AllocateAlignment()));
-  if (size_ + requested > capacity_) return NULL;
-
-  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;
-  return base;
+  Address result = static_cast<Address>(
+      VirtualMemory::ReserveAlignedRegion(size, alignment));
+  size_ += size;
+  return result;
 }
 
 
-Address MemoryAllocator::AllocateAlignedMemory(const size_t requested,
+Address MemoryAllocator::AllocateAlignedMemory(const size_t size,
                                                size_t alignment,
-                                               Executability executable,
-                                               size_t* allocated_size) {
+                                               Executability executable) {
   Address base =
-      ReserveAlignedMemory(requested, Page::kPageSize, allocated_size);
+      ReserveAlignedMemory(size, Page::kPageSize);
 
   if (base == NULL) return NULL;
 
   if (!VirtualMemory::CommitRegion(base,
-                                   *allocated_size,
+                                   size,
                                    executable == EXECUTABLE)) {
-    VirtualMemory::ReleaseRegion(base, *allocated_size);
-    size_ -= *allocated_size;
+    VirtualMemory::ReleaseRegion(base, size);
+    size_ -= size;
     return NULL;
   }
 
   return base;
 }
 
 
 void Page::InitializeAsAnchor(PagedSpace* owner) {
   set_owner(owner);
   set_prev_page(this);
@@ skipping 99 matching lines @@
     // 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));
       size_ += chunk_size;
     } else {
       base = AllocateAlignedMemory(chunk_size,
                                    MemoryChunk::kAlignment,
-                                   executable,
-                                   &chunk_size);
+                                   executable);
     }
 
     if (base == NULL) return NULL;
 
     // Update executable memory size.
     size_executable_ += chunk_size;
   } else {
     base = AllocateAlignedMemory(chunk_size,
                                  MemoryChunk::kAlignment,
-                                 executable,
-                                 &chunk_size);
+                                 executable);
 
     if (base == NULL) return NULL;
   }
 
 #ifdef DEBUG
   ZapBlock(base, chunk_size);
 #endif
   isolate_->counters()->memory_allocated()->
       Increment(static_cast<int>(chunk_size));
 
@@ skipping 299 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);
 
   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));
 
@@ skipping 1647 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