Enable heap compaction on all 'container' arenas.

third_party/WebKit/Source/platform/heap/HeapCompactTest.cpp

 // Copyright 2016 The Chromium 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 "platform/heap/HeapCompact.h"
 
 #include "platform/heap/Handle.h"
 #include "platform/heap/SparseHeapBitmap.h"
 #include "platform/wtf/Deque.h"
 #include "platform/wtf/HashMap.h"
 #include "platform/wtf/LinkedHashSet.h"
 #include "platform/wtf/Vector.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 #include <memory>
 
 namespace {
 
+enum VerifyArenaCompaction {
+  NoVerify,
+  VectorsAreCompacted,
+  HashTablesAreCompacted,
+};
+
 class IntWrapper : public blink::GarbageCollectedFinalized<IntWrapper> {
  public:
-  static IntWrapper* Create(int x) { return new IntWrapper(x); }
+  static IntWrapper* Create(int x, VerifyArenaCompaction verify = NoVerify) {
+    return new IntWrapper(x, verify);
+  }
 
   virtual ~IntWrapper() {}
 
-  DEFINE_INLINE_TRACE() {}
+  DEFINE_INLINE_TRACE() {
+    // Verify if compaction is indeed activated.
+    //
+    // What arenas end up being compacted is dependent on residency,
+    // so approximate the arena checks to fit.
+    blink::HeapCompact* compaction = visitor->Heap().Compaction();
+    switch (verify_) {
+      case NoVerify:
+        return;
+      case HashTablesAreCompacted:
+        CHECK(compaction->IsCompactingArena(
+            blink::BlinkGC::kHashTableArenaIndex));
+        return;
+      case VectorsAreCompacted:
+        CHECK(compaction->IsCompactingVectorArenas());
+        return;
+    }
+  }
 
   int Value() const { return x_; }
 
   bool operator==(const IntWrapper& other) const {
     return other.Value() == Value();
   }
 
   unsigned GetHash() { return IntHash<int>::GetHash(x_); }
 
-  IntWrapper(int x) : x_(x) {}
+  IntWrapper(int x, VerifyArenaCompaction verify) : x_(x), verify_(verify) {}
 
  private:
   IntWrapper();
+
   int x_;
+  VerifyArenaCompaction verify_;
 };
 static_assert(WTF::IsTraceable<IntWrapper>::value,
               "IsTraceable<> template failed to recognize trace method.");
 
 }  // namespace
 
 using IntVector = blink::HeapVector<blink::Member<IntWrapper>>;
 using IntDeque = blink::HeapDeque<blink::Member<IntWrapper>>;
 using IntMap = blink::HeapHashMap<blink::Member<IntWrapper>, int>;
 // TODO(sof): decide if this ought to be a global trait specialization.
@@ skipping 160 matching lines @@
     size_t used = heap.ObjectPayloadSizeForTesting();
     PreciselyCollectGarbage();
     if (heap.ObjectPayloadSizeForTesting() >= used)
       break;
   }
 }
 
 TEST(HeapCompactTest, CompactVector) {
   ClearOutOldGarbage();
 
-  IntWrapper* val = IntWrapper::Create(1);
+  IntWrapper* val = IntWrapper::Create(1, VectorsAreCompacted);
   Persistent<IntVector> vector = new IntVector(10, val);
   EXPECT_EQ(10u, vector->size());
 
   for (size_t i = 0; i < vector->size(); ++i)
     EXPECT_EQ(val, (*vector)[i]);
 
   PerformHeapCompaction();
 
   for (size_t i = 0; i < vector->size(); ++i)
     EXPECT_EQ(val, (*vector)[i]);
 }
 
 TEST(HeapCompactTest, CompactHashMap) {
   ClearOutOldGarbage();
 
   Persistent<IntMap> int_map = new IntMap();
   for (size_t i = 0; i < 100; ++i) {
-    IntWrapper* val = IntWrapper::Create(i);
+    IntWrapper* val = IntWrapper::Create(i, HashTablesAreCompacted);
     int_map->insert(val, 100 - i);
   }
 
   EXPECT_EQ(100u, int_map->size());
   for (auto k : *int_map)
     EXPECT_EQ(k.key->Value(), 100 - k.value);
 
   PerformHeapCompaction();
 
   for (auto k : *int_map)
     EXPECT_EQ(k.key->Value(), 100 - k.value);
 }
 
 TEST(HeapCompactTest, CompactVectorPartHashMap) {
   ClearOutOldGarbage();
 
   using IntMapVector = HeapVector<IntMap>;
 
   Persistent<IntMapVector> int_map_vector = new IntMapVector();
   for (size_t i = 0; i < 10; ++i) {
     IntMap map;
     for (size_t j = 0; j < 10; ++j) {
-      IntWrapper* val = IntWrapper::Create(j);
+      IntWrapper* val = IntWrapper::Create(j, VectorsAreCompacted);
       map.insert(val, 10 - j);
     }
     int_map_vector->push_back(map);
   }
 
   EXPECT_EQ(10u, int_map_vector->size());
   for (auto map : *int_map_vector) {
     EXPECT_EQ(10u, map.size());
     for (auto k : map) {
       EXPECT_EQ(k.key->Value(), 10 - k.value);
@@ skipping 13 matching lines @@
 
 TEST(HeapCompactTest, CompactHashPartVector) {
   ClearOutOldGarbage();
 
   using IntVectorMap = HeapHashMap<int, IntVector>;
 
   Persistent<IntVectorMap> int_vector_map = new IntVectorMap();
   for (size_t i = 0; i < 10; ++i) {
     IntVector vector;
     for (size_t j = 0; j < 10; ++j) {
-      vector.push_back(IntWrapper::Create(j));
+      vector.push_back(IntWrapper::Create(j, HashTablesAreCompacted));
     }
     int_vector_map->insert(1 + i, vector);
   }
 
   EXPECT_EQ(10u, int_vector_map->size());
   for (const IntVector& int_vector : int_vector_map->Values()) {
     EXPECT_EQ(10u, int_vector.size());
     for (size_t i = 0; i < int_vector.size(); ++i) {
       EXPECT_EQ(static_cast<int>(i), int_vector[i]->Value());
     }
   }
 
   PerformHeapCompaction();
 
   EXPECT_EQ(10u, int_vector_map->size());
   for (const IntVector& int_vector : int_vector_map->Values()) {
     EXPECT_EQ(10u, int_vector.size());
     for (size_t i = 0; i < int_vector.size(); ++i) {
       EXPECT_EQ(static_cast<int>(i), int_vector[i]->Value());
     }
   }
 }
 
 TEST(HeapCompactTest, CompactDeques) {
   Persistent<IntDeque> deque = new IntDeque;
   for (int i = 0; i < 8; ++i) {
-    deque->push_front(IntWrapper::Create(i));
+    deque->push_front(IntWrapper::Create(i, VectorsAreCompacted));
   }
   EXPECT_EQ(8u, deque->size());
 
   for (size_t i = 0; i < deque->size(); ++i)
     EXPECT_EQ(static_cast<int>(7 - i), deque->at(i)->Value());
 
   PerformHeapCompaction();
 
   for (size_t i = 0; i < deque->size(); ++i)
     EXPECT_EQ(static_cast<int>(7 - i), deque->at(i)->Value());
 }
 
 TEST(HeapCompactTest, CompactDequeVectors) {
   Persistent<HeapDeque<IntVector>> deque = new HeapDeque<IntVector>;
   for (int i = 0; i < 8; ++i) {
-    IntWrapper* value = IntWrapper::Create(i);
+    IntWrapper* value = IntWrapper::Create(i, VectorsAreCompacted);
     IntVector vector = IntVector(8, value);
     deque->push_front(vector);
   }
   EXPECT_EQ(8u, deque->size());
 
   for (size_t i = 0; i < deque->size(); ++i)
     EXPECT_EQ(static_cast<int>(7 - i), deque->at(i).at(i)->Value());
 
   PerformHeapCompaction();
 
   for (size_t i = 0; i < deque->size(); ++i)
     EXPECT_EQ(static_cast<int>(7 - i), deque->at(i).at(i)->Value());
 }
 
 TEST(HeapCompactTest, CompactLinkedHashSet) {
   using OrderedHashSet = HeapLinkedHashSet<Member<IntWrapper>>;
   Persistent<OrderedHashSet> set = new OrderedHashSet;
   for (int i = 0; i < 13; ++i) {
-    IntWrapper* value = IntWrapper::Create(i);
+    IntWrapper* value = IntWrapper::Create(i, HashTablesAreCompacted);
     set->insert(value);
   }
   EXPECT_EQ(13u, set->size());
 
   int expected = 0;
   for (IntWrapper* v : *set) {
     EXPECT_EQ(expected, v->Value());
     expected++;
   }
 
@@ skipping 85 matching lines @@
 
   expected = 0;
   for (const Inner* v : *set) {
     EXPECT_EQ(1u, v->size());
     EXPECT_EQ(expected, (*v->begin())->Value());
     expected++;
   }
 }
 #endif
 }  // namespace blink