deps: backport e093a04, 09db540 from upstream V8

ofrobots · MylesBorins · commit 2d07fd71ee39 · 2016-10-26T14:09:17.000-04:00
Original commit messages: v8/v8@e093a04 Rehash and clear deleted entries in weak collections during GC Otherwise, they'll just keep growing until we run out of memory or hit the FixedArray's maximum capacity. BUG=v8:4909 R=hpayer@chromium.org LOG=n Review URL: https://codereview.chromium.org/1877233005 Cr-Commit-Position: refs/heads/master@{#35514} v8/v8@09db540 Reland of Rehash and clear deleted entries in weak collections during GC BUG=v8:4909 R=hpayer@chromium.org,ulan@chromium.org LOG=n Review URL: https://codereview.chromium.org/1890123002 Cr-Commit-Position: refs/heads/master@{#35538} Ref: https://crbug.com/v8/4909 Ref: #7883 Fixes: #6180 PR-URL: #7689 Reviewed-By: Matt Loring <mattloring@google.com> Reviewed-By: Ben Noordhuis <info@bnoordhuis.nl>
diff --git a/deps/v8/include/v8-version.h b/deps/v8/include/v8-version.h
@@ -11,7 +11,7 @@
 #define V8_MAJOR_VERSION 4
 #define V8_MINOR_VERSION 5
 #define V8_BUILD_NUMBER 103
-#define V8_PATCH_LEVEL 38
+#define V8_PATCH_LEVEL 39
 
 // Use 1 for candidates and 0 otherwise.
 // (Boolean macro values are not supported by all preprocessors.)
diff --git a/deps/v8/src/heap/mark-compact.cc b/deps/v8/src/heap/mark-compact.cc
@@ -2614,6 +2614,13 @@ void MarkCompactCollector::ClearWeakCollections() {
           table->RemoveEntry(i);
         }
       }
+      // Rehash if more than 25% of the entries are deleted entries.
+      // TODO(jochen): Consider to shrink the fixed array in place.
+      if ((table->NumberOfDeletedElements() << kJSWeakCollectionLoadFactorExp) >
+          table->NumberOfElements()) {
+        HandleScope scope(heap()->isolate());
+        table->Rehash(heap()->isolate()->factory()->undefined_value());
+      }
     }
     weak_collection_obj = weak_collection->next();
     weak_collection->set_next(heap()->undefined_value());
diff --git a/deps/v8/src/heap/mark-compact.h b/deps/v8/src/heap/mark-compact.h
@@ -612,6 +612,10 @@ class MarkCompactCollector {
   static const uint32_t kSingleFreeEncoding = 0;
   static const uint32_t kMultiFreeEncoding = 1;
 
+  // If the number of deleted slots in a JSWeakCollection exceeds the number
+  // of entries / 2^(factor), we rehash the table.
+  static const int kJSWeakCollectionLoadFactorExp = 1;
+
   static inline bool IsMarked(Object* obj);
   static bool IsUnmarkedHeapObjectWithHeap(Heap* heap, Object** p);
 
diff --git a/deps/v8/src/objects.cc b/deps/v8/src/objects.cc
@@ -13744,6 +13744,16 @@ void HashTable<Derived, Shape, Key>::Rehash(Key key) {
       }
     }
   }
+  // Wipe deleted entries.
+  Heap* heap = GetHeap();
+  Object* the_hole = heap->the_hole_value();
+  Object* undefined = heap->undefined_value();
+  for (uint32_t current = 0; current < capacity; current++) {
+    if (get(EntryToIndex(current)) == the_hole) {
+      set(EntryToIndex(current), undefined);
+    }
+  }
+  SetNumberOfDeletedElements(0);
 }
 
 
@@ -14656,6 +14666,7 @@ Handle<CompilationCacheTable> CompilationCacheTable::PutRegExp(
 void CompilationCacheTable::Age() {
   DisallowHeapAllocation no_allocation;
   Object* the_hole_value = GetHeap()->the_hole_value();
+  uint32_t capacity = Capacity();
   for (int entry = 0, size = Capacity(); entry < size; entry++) {
     int entry_index = EntryToIndex(entry);
     int value_index = entry_index + 1;
@@ -14679,6 +14690,16 @@ void CompilationCacheTable::Age() {
       }
     }
   }
+  // Wipe deleted entries.
+  Heap* heap = GetHeap();
+  Object* the_hole = heap->the_hole_value();
+  Object* undefined = heap->undefined_value();
+  for (uint32_t current = 0; current < capacity; current++) {
+    if (get(EntryToIndex(current)) == the_hole) {
+      set(EntryToIndex(current), undefined);
+    }
+  }
+  SetNumberOfDeletedElements(0);
 }
 
 
@@ -15187,6 +15208,12 @@ Handle<ObjectHashTable> ObjectHashTable::Put(Handle<ObjectHashTable> table,
     return table;
   }
 
+  // Rehash if more than 25% of the entries are deleted entries.
+  // TODO(jochen): Consider to shrink the fixed array in place.
+  if ((table->NumberOfDeletedElements() << 1) > table->NumberOfElements()) {
+    table->Rehash(isolate->factory()->undefined_value());
+  }
+
   // Check whether the hash table should be extended.
   table = EnsureCapacity(table, 1, key);
   table->AddEntry(table->FindInsertionEntry(hash), *key, *value);
diff --git a/deps/v8/test/cctest/test-weakmaps.cc b/deps/v8/test/cctest/test-weakmaps.cc
@@ -123,7 +123,7 @@ TEST(Weakness) {
   heap->CollectAllGarbage(false);
   CHECK_EQ(1, NumberOfWeakCalls);
   CHECK_EQ(0, ObjectHashTable::cast(weakmap->table())->NumberOfElements());
-  CHECK_EQ(2,
+  CHECK_EQ(0,
            ObjectHashTable::cast(weakmap->table())->NumberOfDeletedElements());
 }
 
diff --git a/deps/v8/test/cctest/test-weaksets.cc b/deps/v8/test/cctest/test-weaksets.cc
@@ -122,8 +122,8 @@ TEST(WeakSet_Weakness) {
   heap->CollectAllGarbage(false);
   CHECK_EQ(1, NumberOfWeakCalls);
   CHECK_EQ(0, ObjectHashTable::cast(weakset->table())->NumberOfElements());
-  CHECK_EQ(
-      1, ObjectHashTable::cast(weakset->table())->NumberOfDeletedElements());
+  CHECK_EQ(0,
+           ObjectHashTable::cast(weakset->table())->NumberOfDeletedElements());
 }
 
 

Original file line number	Diff line number	Diff line change
`@@ -2614,6 +2614,13 @@ void MarkCompactCollector::ClearWeakCollections() {`
`2614`	`2614`	`table->RemoveEntry(i);`
`2615`	`2615`	`}`
`2616`	`2616`	`}`
	`2617`	`+ // Rehash if more than 25% of the entries are deleted entries.`
	`2618`	`+ // TODO(jochen): Consider to shrink the fixed array in place.`
	`2619`	`+ if ((table->NumberOfDeletedElements() << kJSWeakCollectionLoadFactorExp) >`
	`2620`	`+ table->NumberOfElements()) {`
	`2621`	`+ HandleScope scope(heap()->isolate());`
	`2622`	`+ table->Rehash(heap()->isolate()->factory()->undefined_value());`
	`2623`	`+ }`
`2617`	`2624`	`}`
`2618`	`2625`	`weak_collection_obj = weak_collection->next();`
`2619`	`2626`	`weak_collection->set_next(heap()->undefined_value());`
Original file line number	Diff line number	Diff line change
`@@ -13744,6 +13744,16 @@ void HashTable<Derived, Shape, Key>::Rehash(Key key) {`
`13744`	`13744`	`}`
`13745`	`13745`	`}`
`13746`	`13746`	`}`
	`13747`	`+ // Wipe deleted entries.`
	`13748`	`+ Heap* heap = GetHeap();`
	`13749`	`+ Object* the_hole = heap->the_hole_value();`
	`13750`	`+ Object* undefined = heap->undefined_value();`
	`13751`	`+ for (uint32_t current = 0; current < capacity; current++) {`
	`13752`	`+ if (get(EntryToIndex(current)) == the_hole) {`
	`13753`	`+ set(EntryToIndex(current), undefined);`
	`13754`	`+ }`
	`13755`	`+ }`
	`13756`	`+ SetNumberOfDeletedElements(0);`
`13747`	`13757`	`}`
`13748`	`13758`
`13749`	`13759`
`@@ -14656,6 +14666,7 @@ Handle<CompilationCacheTable> CompilationCacheTable::PutRegExp(`
`14656`	`14666`	`void CompilationCacheTable::Age() {`
`14657`	`14667`	`DisallowHeapAllocation no_allocation;`
`14658`	`14668`	`Object* the_hole_value = GetHeap()->the_hole_value();`
	`14669`	`+ uint32_t capacity = Capacity();`
`14659`	`14670`	`for (int entry = 0, size = Capacity(); entry < size; entry++) {`
`14660`	`14671`	`int entry_index = EntryToIndex(entry);`
`14661`	`14672`	`int value_index = entry_index + 1;`
`@@ -14679,6 +14690,16 @@ void CompilationCacheTable::Age() {`
`14679`	`14690`	`}`
`14680`	`14691`	`}`
`14681`	`14692`	`}`
	`14693`	`+ // Wipe deleted entries.`
	`14694`	`+ Heap* heap = GetHeap();`
	`14695`	`+ Object* the_hole = heap->the_hole_value();`
	`14696`	`+ Object* undefined = heap->undefined_value();`
	`14697`	`+ for (uint32_t current = 0; current < capacity; current++) {`
	`14698`	`+ if (get(EntryToIndex(current)) == the_hole) {`
	`14699`	`+ set(EntryToIndex(current), undefined);`
	`14700`	`+ }`
	`14701`	`+ }`
	`14702`	`+ SetNumberOfDeletedElements(0);`
`14682`	`14703`	`}`
`14683`	`14704`
`14684`	`14705`
`@@ -15187,6 +15208,12 @@ Handle<ObjectHashTable> ObjectHashTable::Put(Handle<ObjectHashTable> table,`
`15187`	`15208`	`return table;`
`15188`	`15209`	`}`
`15189`	`15210`
	`15211`	`+ // Rehash if more than 25% of the entries are deleted entries.`
	`15212`	`+ // TODO(jochen): Consider to shrink the fixed array in place.`
	`15213`	`+ if ((table->NumberOfDeletedElements() << 1) > table->NumberOfElements()) {`
	`15214`	`+ table->Rehash(isolate->factory()->undefined_value());`
	`15215`	`+ }`
	`15216`	`+`
`15190`	`15217`	`// Check whether the hash table should be extended.`
`15191`	`15218`	`table = EnsureCapacity(table, 1, key);`
`15192`	`15219`	`table->AddEntry(table->FindInsertionEntry(hash), key, value);`
Original file line number	Diff line number	Diff line change
`@@ -123,7 +123,7 @@ TEST(Weakness) {`
`123`	`123`	`heap->CollectAllGarbage(false);`
`124`	`124`	`CHECK_EQ(1, NumberOfWeakCalls);`
`125`	`125`	`CHECK_EQ(0, ObjectHashTable::cast(weakmap->table())->NumberOfElements());`
`126`		`- CHECK_EQ(2,`
	`126`	`+ CHECK_EQ(0,`
`127`	`127`	`ObjectHashTable::cast(weakmap->table())->NumberOfDeletedElements());`
`128`	`128`	`}`
`129`	`129`
Original file line number	Diff line number	Diff line change
`@@ -122,8 +122,8 @@ TEST(WeakSet_Weakness) {`
`122`	`122`	`heap->CollectAllGarbage(false);`
`123`	`123`	`CHECK_EQ(1, NumberOfWeakCalls);`
`124`	`124`	`CHECK_EQ(0, ObjectHashTable::cast(weakset->table())->NumberOfElements());`
`125`		`- CHECK_EQ(`
`126`		`- 1, ObjectHashTable::cast(weakset->table())->NumberOfDeletedElements());`
	`125`	`+ CHECK_EQ(0,`
	`126`	`+ ObjectHashTable::cast(weakset->table())->NumberOfDeletedElements());`
`127`	`127`	`}`
`128`	`128`
`129`	`129`