Do inline object filtering (via page flags) before call to RecordWriteStub.

src/spaces.h

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 321 matching lines @@
     }
   }
 
   void set_owner(Space* space) {
     ASSERT((reinterpret_cast<intptr_t>(space) & kFailureTagMask) == 0);
     owner_ = reinterpret_cast<Address>(space) + kFailureTag;
     ASSERT((reinterpret_cast<intptr_t>(owner_) & kFailureTagMask) ==
            kFailureTag);
   }
 
-  bool scan_on_scavenge() { return scan_on_scavenge_; }
-  void initialize_scan_on_scavenge(bool scan) { scan_on_scavenge_ = scan; }
+  bool scan_on_scavenge() { return IsFlagSet(SCAN_ON_SCAVENGE); }
+  void initialize_scan_on_scavenge(bool scan) {
+    if (scan) {
+      SetFlag(SCAN_ON_SCAVENGE);
+    } else {
+      ClearFlag(SCAN_ON_SCAVENGE);
+    }
+  }
   inline void set_scan_on_scavenge(bool scan);
 
   int store_buffer_counter() { return store_buffer_counter_; }
   void set_store_buffer_counter(int counter) {
     store_buffer_counter_ = counter;
   }
 
   Address body() { return address() + kObjectStartOffset; }
 
   int body_size() { return size() - kObjectStartOffset; }
 
   bool Contains(Address addr) {
     return addr >= body() && addr < address() + size();
   }
 
   enum MemoryChunkFlags {
     IS_EXECUTABLE,
     WAS_SWEPT_CONSERVATIVELY,
     CONTAINS_ONLY_DATA,
+    CONTAINS_INTERESTING_VALUES,
+    CONTAINS_INTERESTING_DESTINATIONS,

[Erik Corry, 2011/05/11 18:53:57]

I don't like these names.  If a pointer points from one object to another how
can the destination be the 'from' object.

How about POINTERS_FROM_HERE_ARE_INTERESTING and
POINTERS_TO_HERE_ARE_INTERESTING

[Vyacheslav Egorov (Chromium), 2011/05/13 11:06:52]

Done.

+    SCAN_ON_SCAVENGE,
     NUM_MEMORY_CHUNK_FLAGS
   };
 
   void SetFlag(int flag) {
     flags_ |= 1 << flag;
   }
 
   void ClearFlag(int flag) {
     flags_ &= ~(1 << flag);
   }
 
   bool IsFlagSet(int flag) {
     return (flags_ & (1 << flag)) != 0;
   }
 
+  void CopyFlagsFrom(MemoryChunk* chunk) {
+    flags_ = chunk->flags_;
+  }
+
   static const intptr_t kAlignment = (1 << kPageSizeBits);
 
   static const intptr_t kAlignmentMask = kAlignment - 1;
 
   static const size_t kHeaderSize = kPointerSize + kPointerSize + kPointerSize +
     kPointerSize + kPointerSize + kPointerSize + kPointerSize + kPointerSize;
 
   static const size_t kMarksBitmapLength =
     (1 << kPageSizeBits) >> (kPointerSizeLog2);
 
@@ skipping 53 matching lines @@
   inline Address MarkbitIndexToAddress(uint32_t index) {
     return this->address() + (index << kPointerSizeLog2);
   }
 
   void InsertAfter(MemoryChunk* other);
   void Unlink();
 
   inline Heap* heap() { return heap_; }
 
   static const int kFlagsOffset = kPointerSize * 3;
-  static const int kScanOnScavengeOffset = kPointerSize * 6;
 
  protected:
   MemoryChunk* next_chunk_;
   MemoryChunk* prev_chunk_;
   size_t size_;
   intptr_t flags_;
   // The identity of the owning space.  This is tagged as a failure pointer, but
   // no failure can be in an object, so this can be distinguished from any entry
   // in a fixed array.
   Address owner_;
   Heap* heap_;
-  // This flag indicates that the page is not being tracked by the store buffer.
-  // At any point where we have to iterate over pointers to new space, we must
-  // search this page for pointers to new space.
-  bool scan_on_scavenge_;
   // Used by the store buffer to keep track of which pages to mark scan-on-
   // scavenge.
   int store_buffer_counter_;
 
   static MemoryChunk* Initialize(Heap* heap,
                                  Address base,
                                  size_t size,
                                  Executability executable,
                                  Space* owner);
 
@@ skipping 102 matching lines @@
   }
 
   inline LargePage* next_page() const {
     return static_cast<LargePage*>(next_chunk());
   }
 
   inline void set_next_page(LargePage* page) {
     set_next_chunk(page);
   }
  private:
-  static LargePage* Initialize(Heap* heap,
-                               MemoryChunk* chunk) {
-    // TODO(gc) ISOLATESMERGE initialize chunk to point to heap?
-    return static_cast<LargePage*>(chunk);
-  }
+  static inline LargePage* Initialize(Heap* heap, MemoryChunk* chunk);
 
   friend class MemoryAllocator;
 };
 
 STATIC_CHECK(sizeof(LargePage) <= MemoryChunk::kHeaderSize);
 
 // ----------------------------------------------------------------------------
 // Space is the abstract superclass for all allocation spaces.
 class Space : public Malloced {
  public:
@@ skipping 1251 matching lines @@
 
   bool UncommitFromSpace() {
     if (!from_space_.is_committed()) return true;
     return from_space_.Uncommit();
   }
 
   inline intptr_t inline_alloction_limit_step() {
     return inline_alloction_limit_step_;
   }
 
+  NewSpacePage* ActivePage() {
+    return to_space_.current_page();
+  }
+
  private:
   Address chunk_base_;
   uintptr_t chunk_size_;
 
   // The semispaces.
   SemiSpace to_space_;
   SemiSpace from_space_;
 
   // Start address and bit mask for containment testing.
   Address start_;
@@ skipping 249 matching lines @@
   // called after ReserveSpace has been called on the paged spaces, since they
   // may use some memory, leaving less for large objects.
   virtual bool ReserveSpace(int bytes);
 
 #ifdef ENABLE_HEAP_PROTECTION
   // Protect/unprotect the space by marking it read-only/writable.
   void Protect();
   void Unprotect();
 #endif
 
+  LargePage* first_page() { return first_page_; }
+
 #ifdef DEBUG
   virtual void Verify();
   virtual void Print();
   void ReportStatistics();
   void CollectCodeStatistics();
 #endif
   // Checks whether an address is in the object area in this space.  It
   // iterates all objects in the space. May be slow.
   bool SlowContains(Address addr) { return !FindObject(addr)->IsFailure(); }
 
@@ skipping 105 matching lines @@
   }
   // Must be small, since an iteration is used for lookup.
   static const int kMaxComments = 64;
 };
 #endif
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_SPACES_H_