Move aligned allocation to the platform files.

src/platform-win32.cc

-// Copyright 2006-2008 the V8 project authors. All rights reserved.
+// 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
 //       with the distribution.
@@ skipping 1484 matching lines @@
   ASSERT(IsReserved());
   return UncommitRegion(address, size);
 }
 
 
 void* VirtualMemory::ReserveRegion(size_t size) {
   return VirtualAlloc(NULL, size, MEM_RESERVE, PAGE_NOACCESS);
 }
 
 
+void* VirtualMemory::ReserveAlignedRegion(size_t size, size_t alignment) {
+  ASSERT(IsAligned(alignment, static_cast<intptr_t>(OS::AllocateAlignment())));
+  size_t request_size = RoundUp(size + alignment,
+                                static_cast<intptr_t>(OS::AllocateAlignment()));
+  Address result;
+  do {
+    void* reservation =
+        VirtualAlloc(NULL, request_size, MEM_RESERVE, PAGE_NOACCESS);
+    // If we can't allocate at all, give up.
+    if (reservation == NULL) return NULL;
+    Address base = static_cast<Address>(reservation);
+    Address aligned_base = RoundUp(base, alignment);
+    ASSERT(base <= aligned_base);
+    // Try to reallocate part of the original allocation by first freeing it,
+    // and then allocating with a specific target address in the middle of
+    // the freed area.
+    // This can fail in the rare case that someone else in the same process
+    // allocates the same memory between the VirtualFree and VirtualAlloc
+    // calls. In that case, just try again.
+    VirtualFree(reservation, 0, MEM_RELEASE);
+    reservation = VirtualAlloc(aligned_base, size, MEM_RESERVE, PAGE_NOACCESS);
+    result = static_cast<Address>(reservation);
+    ASSERT(result == NULL || result == aligned_base);
+  } while (result == NULL);

[Vyacheslav Egorov (Chromium), 2011/09/12 13:42:48]

this looks too fragile and might go into infinite loop. 

lets limit number of retries and fallback to "wasteful" allocation if it fails.
to make "wasteful" allocation work property we need to track the base pointer to
enable correct virtualfree with MEM_RELEASE later (e.g. NewSpace can own base
pointer for deallocation of aligned new space chunk; pages can track base
pointer in the header. etc.).

[Lasse Reichstein, 2011/09/12 19:18:02]

This was an attempt to avoid finding a place to store that pointer.
The infinite loop is implausible, but I agree, not impossible. I guess this
needs rethinking.

+
+  return static_cast<void*>(result);
+}
+
+
 bool VirtualMemory::CommitRegion(void* base, size_t size, bool is_executable) {
   int prot = is_executable ? PAGE_EXECUTE_READWRITE : PAGE_READWRITE;
   if (NULL == VirtualAlloc(base, size, MEM_COMMIT, prot)) {
     return false;
   }
 
   UpdateAllocatedSpaceLimits(base, static_cast<int>(size));
   return true;
 }
 
 
 bool VirtualMemory::UncommitRegion(void* base, size_t size) {
-  return VirtualFree(base, size, MEM_DECOMMIT) != false;
+  return VirtualFree(base, size, MEM_DECOMMIT) != 0;
 }
 
 
 bool VirtualMemory::ReleaseRegion(void* base, size_t size) {
-  return VirtualFree(base, size, MEM_DECOMMIT) != false;
+  return VirtualFree(base, 0, MEM_DECOMMIT) != 0;

[Vyacheslav Egorov (Chromium), 2011/09/12 13:42:48]

Should not it become MEM_RELEASE?

[Lasse Reichstein, 2011/09/12 19:18:02]

Absolutely! It should have been that all along! This means we never release
memory. How inconvenient.

 }
 
 
 
 // ----------------------------------------------------------------------------
 // Win32 thread support.
 
 // Definition of invalid thread handle and id.
 static const HANDLE kNoThread = INVALID_HANDLE_VALUE;
 
@@ skipping 529 matching lines @@
 
 
 void Sampler::Stop() {
   ASSERT(IsActive());
   SamplerThread::RemoveActiveSampler(this);
   SetActive(false);
 }
 
 
 } }  // namespace v8::internal