Revert "[wasm] A simple allocator datastructure for off-the heap"

This reverts commit 110d9ab0.

Reason for revert: https://build.chromium.org/p/client.v8/builders/V8%20Linux64%20-%20debug%20builder/builds/26607

Surprising we're seeing a failure on Linux 64 *after* CQ. Is the compiler there different?

Original change's description:
> [wasm] A simple allocator datastructure for off-the heap
> 
> We'll use this allocator in a follow-up CL to:
> - allocate speculative sizes of memory for a module that's being
> compiled (e.g. 2*size of wasm code).
> - each module will own such a sub-pool, and then use it to allocate
> contiguous chunks of memory for code.
> 
> The underlying assumptions for the chosen allocation strategy is that:
> - the allocation granularity for pools is 1 page, so that no one page
> is owned by more than one wasm module
> - typical pool sizes (given module sizes) are multiple pages.
> - modules and module instances are typically few and long lived. Typically,
> we expect one module and one instance. 
> 
> This means we shouldn't expect fragmentations that lead to code being
> non-allocatable, or prohibitively many ranges.
> 
> The data structure just manages ranges of addresses. Virtual memory management
> will be separate, as part of the responsibility of a "WasmHeap"
> that will be introduced in the future. So will concurrency control.
> 
> Bug: 
> Change-Id: Id99f46d10c25553b013054d994760f3c2a737c39
> Reviewed-on: https://chromium-review.googlesource.com/669296
> Commit-Queue: Mircea Trofin <mtrofin@chromium.org>
> Reviewed-by: Eric Holk <eholk@chromium.org>
> Reviewed-by: Brad Nelson <bradnelson@chromium.org>
> Cr-Commit-Position: refs/heads/master@{#48053}

TBR=bradnelson@chromium.org,mtrofin@chromium.org,eholk@chromium.org

Change-Id: Id82fa341b77624e4971f24c4757a9a666a65930c
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Reviewed-on: https://chromium-review.googlesource.com/670141Reviewed-by: Mircea Trofin <mtrofin@chromium.org>
Commit-Queue: Mircea Trofin <mtrofin@chromium.org>
Cr-Commit-Position: refs/heads/master@{#48054}

BUILD.gn

@@ -2059,8 +2059,6 @@ v8_source_set("v8_base") {
     "src/wasm/wasm-debug.cc",
     "src/wasm/wasm-external-refs.cc",
     "src/wasm/wasm-external-refs.h",
-    "src/wasm/wasm-heap.cc",
-    "src/wasm/wasm-heap.h",
     "src/wasm/wasm-interpreter.cc",
     "src/wasm/wasm-interpreter.h",
     "src/wasm/wasm-js.cc",

src/v8.gyp

@@ -1447,8 +1447,6 @@
         'wasm/wasm-debug.cc',
         'wasm/wasm-external-refs.cc',
         'wasm/wasm-external-refs.h',
-        'wasm/wasm-heap.cc',
-        'wasm/wasm-heap.h',
         'wasm/wasm-js.cc',
         'wasm/wasm-js.h',
         'wasm/wasm-limits.h',

src/wasm/wasm-heap.cc

-// Copyright 2017 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 "src/wasm/wasm-heap.h"
-
-namespace v8 {
-namespace internal {
-namespace wasm {
-
-DisjointAllocationPool::DisjointAllocationPool(Address start, Address end) {
-  ranges_.push_back({start, end});
-}
-
-void DisjointAllocationPool::Release(DisjointAllocationPool&& other) {
-  auto dest_it = ranges_.begin();
-  auto dest_end = ranges_.end();
-
-  for (auto src_it = other.ranges_.begin(), src_end = other.ranges_.end();
-       src_it != src_end;) {
-    if (dest_it == dest_end) {
-      // everything else coming from src will be inserted
-      // at the back of ranges_ from now on.
-      ranges_.push_back(*src_it);
-      ++src_it;
-      continue;
-    }
-    // Before or adjacent to dest. Insert or merge, and advance
-    // just src.
-    if (dest_it->first >= src_it->second) {
-      if (dest_it->first == src_it->second) {
-        dest_it->first = src_it->first;
-      } else {
-        ranges_.insert(dest_it, {src_it->first, src_it->second});
-      }
-      ++src_it;
-      continue;
-    }
-    // Src is strictly after dest. Skip over this dest.
-    if (dest_it->second < src_it->first) {
-      ++dest_it;
-      continue;
-    }
-    // Src is adjacent from above. Merge and advance
-    // just src, because the next src, if any, is bound to be
-    // strictly above the newly-formed range.
-    DCHECK_EQ(dest_it->second, src_it->first);
-    dest_it->second = src_it->second;
-    ++src_it;
-    // Now that we merged, maybe this new range is adjacent to
-    // the next. Since we assume src to have come from the
-    // same original memory pool, it follows that the next src
-    // must be above or adjacent to the new bubble.
-    auto next_dest = dest_it;
-    ++next_dest;
-    if (next_dest != dest_end && dest_it->second == next_dest->first) {
-      dest_it->second = next_dest->second;
-      ranges_.erase(next_dest);
-    }
-
-    // src_it points now at the next, if any, src
-    DCHECK_IMPLIES(src_it != src_end, src_it->first >= dest_it->second);
-  }
-}
-
-DisjointAllocationPool DisjointAllocationPool::Extract(size_t size,
-                                                       ExtractionMode mode) {
-  DisjointAllocationPool ret;
-  for (auto it = ranges_.begin(), end = ranges_.end(); it != end;) {
-    auto current = it;
-    ++it;
-    DCHECK_LT(current->first, current->second);
-    size_t current_size = reinterpret_cast<size_t>(current->second) -
-                          reinterpret_cast<size_t>(current->first);
-    if (size == current_size) {
-      ret.ranges_.push_back(*current);
-      ranges_.erase(current);
-      return ret;
-    }
-    if (size < current_size) {
-      ret.ranges_.push_back({current->first, current->first + size});
-      current->first += size;
-      DCHECK(current->first < current->second);
-      return ret;
-    }
-    if (mode != kContiguous) {
-      size -= current_size;
-      ret.ranges_.push_back(*current);
-      ranges_.erase(current);
-    }
-  }
-  if (size > 0) {
-    Release(std::move(ret));
-    return {};
-  }
-  return ret;
-}
-
-}  // namespace wasm
-}  // namespace internal
-}  // namespace v8

src/wasm/wasm-heap.h

-// Copyright 2017 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.
-
-#ifndef V8_WASM_HEAP_H_
-#define V8_WASM_HEAP_H_
-
-#include <list>
-
-#include "src/base/macros.h"
-#include "src/vector.h"
-
-namespace v8 {
-namespace internal {
-namespace wasm {
-
-// Sorted, disjoint and non-overlapping memory ranges. A range is of the
-// form [start, end). So there's no [start, end), [end, other_end),
-// because that should have been reduced to [start, other_end).
-using AddressRange = std::pair<Address, Address>;
-class V8_EXPORT_PRIVATE DisjointAllocationPool final {
- public:
-  enum ExtractionMode : bool { kAny = false, kContiguous = true };
-  DisjointAllocationPool() {}
-
-  explicit DisjointAllocationPool(Address, Address);
-
-  DisjointAllocationPool(DisjointAllocationPool&& other) = default;
-  DisjointAllocationPool& operator=(DisjointAllocationPool&& other) = default;
-
-  // Merge the ranges of the parameter into this object. Ordering is
-  // preserved. The assumption is that the passed parameter is
-  // not intersecting this object - for example, it was obtained
-  // from a previous Allocate{Pool}.
-  void Release(DisjointAllocationPool&&);
-
-  // Allocate a contiguous range of size {size}. Return an empty pool on
-  // failure.
-  DisjointAllocationPool Allocate(size_t size) {
-    return Extract(size, kContiguous);
-  }
-
-  // Allocate a sub-pool of size {size}. Return an empty pool on failure.
-  DisjointAllocationPool AllocatePool(size_t size) {
-    return Extract(size, kAny);
-  }
-
-  bool IsEmpty() const { return ranges_.empty(); }
-  const std::list<AddressRange>& ranges() const { return ranges_; }
-
- private:
-  // Extract out a total of {size}. By default, the return may
-  // be more than one range. If kContiguous is passed, the return
-  // will be one range. If the operation fails, this object is
-  // unchanged, and the return {IsEmpty()}
-  DisjointAllocationPool Extract(size_t size, ExtractionMode mode);
-
-  std::list<AddressRange> ranges_;
-
-  DISALLOW_COPY_AND_ASSIGN(DisjointAllocationPool)
-};
-
-}  // namespace wasm
-}  // namespace internal
-}  // namespace v8
-#endif

test/unittests/BUILD.gn

@@ -157,7 +157,6 @@ v8_executable("unittests") {
     "wasm/loop-assignment-analysis-unittest.cc",
     "wasm/module-decoder-unittest.cc",
     "wasm/streaming-decoder-unittest.cc",
-    "wasm/wasm-heap-unittest.cc",
     "wasm/wasm-macro-gen-unittest.cc",
     "wasm/wasm-module-builder-unittest.cc",
     "wasm/wasm-opcodes-unittest.cc",

test/unittests/unittests.gyp

@@ -154,7 +154,6 @@
       'wasm/control-transfer-unittest.cc',
       'wasm/decoder-unittest.cc',
       'wasm/function-body-decoder-unittest.cc',
-      'wasm/wasm-heap-unittest.cc',
       'wasm/leb-helper-unittest.cc',
       'wasm/loop-assignment-analysis-unittest.cc',
       'wasm/module-decoder-unittest.cc',

test/unittests/wasm/wasm-heap-unittest.cc

-// Copyright 2017 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 "test/unittests/test-utils.h"
-#include "testing/gmock/include/gmock/gmock.h"
-
-#include "src/wasm/wasm-heap.h"
-
-namespace v8 {
-namespace internal {
-namespace wasm {
-
-class DisjointAllocationPoolTest : public testing::Test {
- public:
-  Address A(size_t n) { return reinterpret_cast<Address>(n); }
-  void CheckLooksLike(const DisjointAllocationPool& mem,
-                      std::vector<std::pair<size_t, size_t>> expectation);
-  DisjointAllocationPool Make(std::vector<std::pair<size_t, size_t>> model);
-};
-
-void DisjointAllocationPoolTest::CheckLooksLike(
-    const DisjointAllocationPool& mem,
-    std::vector<std::pair<size_t, size_t>> expectation) {
-  const auto& ranges = mem.ranges();
-  CHECK_EQ(ranges.size(), expectation.size());
-  auto iter = expectation.begin();
-  for (auto it = ranges.begin(), e = ranges.end(); it != e; ++it, ++iter) {
-    CHECK_EQ(it->first, A(iter->first));
-    CHECK_EQ(it->second, A(iter->second));
-  }
-}
-
-DisjointAllocationPool DisjointAllocationPoolTest::Make(
-    std::vector<std::pair<size_t, size_t>> model) {
-  DisjointAllocationPool ret;
-  for (auto& pair : model) {
-    ret.Release(DisjointAllocationPool(A(pair.first), A(pair.second)));
-  }
-  return ret;
-}
-
-TEST_F(DisjointAllocationPoolTest, Construct) {
-  DisjointAllocationPool a;
-  CHECK(a.IsEmpty());
-  CHECK_EQ(a.ranges().size(), 0);
-  DisjointAllocationPool b = Make({{1, 5}});
-  CHECK(!b.IsEmpty());
-  CHECK_EQ(b.ranges().size(), 1);
-  a.Release(std::move(b));
-  CheckLooksLike(a, {{1, 5}});
-  DisjointAllocationPool c;
-  a.Release(std::move(c));
-  CheckLooksLike(a, {{1, 5}});
-  DisjointAllocationPool e, f;
-  e.Release(std::move(f));
-  CHECK(e.IsEmpty());
-}
-
-TEST_F(DisjointAllocationPoolTest, SimpleExtract) {
-  DisjointAllocationPool a = Make({{1, 5}});
-  DisjointAllocationPool b = a.AllocatePool(2);
-  CheckLooksLike(a, {{3, 5}});
-  CheckLooksLike(b, {{1, 3}});
-  a.Release(std::move(b));
-  CheckLooksLike(a, {{1, 5}});
-  CHECK_EQ(a.ranges().size(), 1);
-  CHECK_EQ(a.ranges().front().first, A(1));
-  CHECK_EQ(a.ranges().front().second, A(5));
-}
-
-TEST_F(DisjointAllocationPoolTest, ExtractAll) {
-  DisjointAllocationPool a(A(1), A(5));
-  DisjointAllocationPool b = a.AllocatePool(4);
-  CheckLooksLike(b, {{1, 5}});
-  CheckLooksLike(a, {});
-  a.Release(std::move(b));
-  CheckLooksLike(a, {{1, 5}});
-}
-
-TEST_F(DisjointAllocationPoolTest, ExtractAccross) {
-  DisjointAllocationPool a = Make({{1, 5}, {10, 20}});
-  DisjointAllocationPool b = a.AllocatePool(5);
-  CheckLooksLike(a, {{11, 20}});
-  CheckLooksLike(b, {{1, 5}, {10, 11}});
-  a.Release(std::move(b));
-  CheckLooksLike(a, {{1, 5}, {10, 20}});
-}
-
-TEST_F(DisjointAllocationPoolTest, ReassembleOutOfOrder) {
-  DisjointAllocationPool a = Make({{1, 5}, {10, 15}});
-  DisjointAllocationPool b = Make({{7, 8}, {20, 22}});
-  a.Release(std::move(b));
-  CheckLooksLike(a, {{1, 5}, {7, 8}, {10, 15}, {20, 22}});
-
-  DisjointAllocationPool c = Make({{1, 5}, {10, 15}});
-  DisjointAllocationPool d = Make({{7, 8}, {20, 22}});
-  d.Release(std::move(c));
-  CheckLooksLike(d, {{1, 5}, {7, 8}, {10, 15}, {20, 22}});
-}
-
-TEST_F(DisjointAllocationPoolTest, FailToExtract) {
-  DisjointAllocationPool a = Make({{1, 5}});
-  DisjointAllocationPool b = a.AllocatePool(5);
-  CheckLooksLike(a, {{1, 5}});
-  CHECK(b.IsEmpty());
-}
-
-TEST_F(DisjointAllocationPoolTest, FailToExtractExact) {
-  DisjointAllocationPool a = Make({{1, 5}, {10, 14}});
-  DisjointAllocationPool b = a.Allocate(5);
-  CheckLooksLike(a, {{1, 5}, {10, 14}});
-  CHECK(b.IsEmpty());
-}
-
-TEST_F(DisjointAllocationPoolTest, ExtractExact) {
-  DisjointAllocationPool a = Make({{1, 5}, {10, 15}});
-  DisjointAllocationPool b = a.Allocate(5);
-  CheckLooksLike(a, {{1, 5}});
-  CheckLooksLike(b, {{10, 15}});
-}
-
-TEST_F(DisjointAllocationPoolTest, Merging) {
-  DisjointAllocationPool a = Make({{10, 15}, {20, 25}});
-  a.Release(Make({{15, 20}}));
-  CheckLooksLike(a, {{10, 25}});
-}
-
-TEST_F(DisjointAllocationPoolTest, MergingMore) {
-  DisjointAllocationPool a = Make({{10, 15}, {20, 25}, {30, 35}});
-  a.Release(Make({{15, 20}, {25, 30}}));
-  CheckLooksLike(a, {{10, 35}});
-}
-
-TEST_F(DisjointAllocationPoolTest, MergingSkip) {
-  DisjointAllocationPool a = Make({{10, 15}, {20, 25}, {30, 35}});
-  a.Release(Make({{25, 30}}));
-  CheckLooksLike(a, {{10, 15}, {20, 35}});
-}
-
-TEST_F(DisjointAllocationPoolTest, MergingSkipLargerSrc) {
-  DisjointAllocationPool a = Make({{10, 15}, {20, 25}, {30, 35}});
-  a.Release(Make({{25, 30}, {35, 40}}));
-  CheckLooksLike(a, {{10, 15}, {20, 40}});
-}
-
-TEST_F(DisjointAllocationPoolTest, MergingSkipLargerSrcWithGap) {
-  DisjointAllocationPool a = Make({{10, 15}, {20, 25}, {30, 35}});
-  a.Release(Make({{25, 30}, {36, 40}}));
-  CheckLooksLike(a, {{10, 15}, {20, 35}, {36, 40}});
-}
-
-}  // namespace wasm
-}  // namespace internal
-}  // namespace v8