[d8] Use virtual memory to allocate large array buffers.

src/d8.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <errno.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/stat.h>
 
 #include <algorithm>
@@ skipping 44 matching lines @@
 #define CHECK(condition) assert(condition)
 #endif
 
 namespace v8 {
 
 namespace {
 
 const int MB = 1024 * 1024;
 const int kMaxWorkers = 50;
 
+#define USE_VM 1
+#define VM_THRESHOLD 65536
 
 class ShellArrayBufferAllocator : public v8::ArrayBuffer::Allocator {
  public:
   virtual void* Allocate(size_t length) {
+#if USE_VM
+    if (RoundToPageSize(&length)) {
+      void* data = base::VirtualMemory::ReserveRegion(length);
+      if (data && !base::VirtualMemory::CommitRegion(data, length, false)) {

[Michael Starzinger, 2016/11/21 13:58:09]

This relies on the mamory being provided by the underlying platform
implementation of {VirtualMemory} being zero-initialized. I don't think we rely
on this anywhere else in V8. Does this hold on all platforms?

Also is ASAN fine with not explicitly initializing the memory first? I see a
try-bot for ASAN in the CQ and it seems to be green. So assume that this path is
covered on that bot?

[Michael Starzinger, 2016/11/21 13:59:33]

Same for the other *SANs, not sure which one it is. :)

+        base::VirtualMemory::ReleaseRegion(data, length);
+        data = nullptr;
+      }
+      return data;
+    }
+#endif

[Clemens Hammacher, 2016/11/21 14:00:28]

The code duplication bothers me. We call AllocateUninitialized anyway, so can't
we just skip the memset if RoundToPageSize(&length)?

     void* data = AllocateUninitialized(length);
     return data == NULL ? data : memset(data, 0, length);
   }
-  virtual void* AllocateUninitialized(size_t length) { return malloc(length); }
-  virtual void Free(void* data, size_t) { free(data); }
+  virtual void* AllocateUninitialized(size_t length) {
+#if USE_VM
+    if (RoundToPageSize(&length)) {
+      void* data = base::VirtualMemory::ReserveRegion(length);
+      if (data && !base::VirtualMemory::CommitRegion(data, length, false)) {
+        base::VirtualMemory::ReleaseRegion(data, length);
+        data = nullptr;
+      }
+      return data;
+    }
+#endif
+    return malloc(length);
+  }
+  virtual void Free(void* data, size_t length) {
+#if USE_VM
+    if (RoundToPageSize(&length)) {
+      base::VirtualMemory::ReleaseRegion(data, length);
+      return;
+    }
+#endif
+    free(data);
+  }
+  // If {length} is at least a page, round up to next page size and return

[Clemens Hammacher, 2016/11/21 14:00:28]

... at least VM_THRESHOLD, ...

+  // {true}.
+  // Otherwise return {false}.
+  bool RoundToPageSize(size_t* length) {
+    const size_t kPageSize = base::OS::CommitPageSize();
+    if (*length >= VM_THRESHOLD) {
+      *length = ((*length + kPageSize - 1) / kPageSize) * kPageSize;
+      return true;
+    }
+    return false;
+  }
 };
 
 
 class MockArrayBufferAllocator : public v8::ArrayBuffer::Allocator {
  public:
   void* Allocate(size_t length) override {
     size_t actual_length = length > 10 * MB ? 1 : length;
     void* data = AllocateUninitialized(actual_length);
     return data == NULL ? data : memset(data, 0, actual_length);
   }
@@ skipping 2880 matching lines @@
 }
 
 }  // namespace v8
 
 
 #ifndef GOOGLE3
 int main(int argc, char* argv[]) {
   return v8::Shell::Main(argc, argv);
 }
 #endif