[heap] Move typed slot filtering logic into sweeper.

src/heap/slot-set.h

 // Copyright 2016 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_SLOT_SET_H
 #define V8_SLOT_SET_H
 
+#include <map>
 #include <stack>
 
 #include "src/allocation.h"
 #include "src/base/atomic-utils.h"
 #include "src/base/bits.h"
 #include "src/utils.h"
 
 namespace v8 {
 namespace internal {
 
@@ skipping 435 matching lines @@
 
   void FreeToBeFreedChunks() {
     base::LockGuard<base::Mutex> guard(&to_be_freed_chunks_mutex_);
     while (!to_be_freed_chunks_.empty()) {
       Chunk* top = to_be_freed_chunks_.top();
       to_be_freed_chunks_.pop();
       delete top;
     }
   }
 
+  void RemoveInvaldSlots(std::map<uint32_t, uint32_t>& invalid_ranges) {
+    Chunk* chunk = chunk_.Value();
+    while (chunk != nullptr) {
+      TypedSlot* buffer = chunk->buffer.Value();
+      int count = chunk->count.Value();
+      for (int i = 0; i < count; i++) {
+        uint32_t host_offset = buffer[i].host_offset();
+        std::map<uint32_t, uint32_t>::iterator upper_bound =
+            invalid_ranges.upper_bound(host_offset);

[ulan, 2016/10/20 15:48:19]

if (upper_bound == invalid_ranges.begin()) continue;
Could you also add a test for this case?

[Hannes Payer (out of office), 2016/10/21 07:13:30]

Done.

+        // upper_bounds points to the invalid range after the given slot. Hence,
+        // we have to go to the previous element.
+        upper_bound--;
+        if (upper_bound->first <= host_offset &&

[ulan, 2016/10/20 15:48:19]

DCHECK_LE(upper_bound->first, host_offset);
This should be guaranteed by the upper_bound() function.

[Hannes Payer (out of office), 2016/10/21 07:13:29]

Done.

+            upper_bound->second > host_offset) {
+          buffer[i].Clear();
+        }
+      }
+      chunk = chunk->next.Value();
+    }
+  }
+
  private:
   static const int kInitialBufferSize = 100;
   static const int kMaxBufferSize = 16 * KB;
 
   static int NextCapacity(int capacity) {
     return Min(kMaxBufferSize, capacity * 2);
   }
 
   class OffsetField : public BitField<int, 0, 29> {};
   class TypeField : public BitField<SlotType, 29, 3> {};
@@ skipping 26 matching lines @@
   Address page_start_;
   base::AtomicValue<Chunk*> chunk_;
   base::Mutex to_be_freed_chunks_mutex_;
   std::stack<Chunk*> to_be_freed_chunks_;
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_SLOT_SET_H