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

src/spaces-inl.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 109 matching lines @@
                        PagedSpace* owner) {
   Page* page = reinterpret_cast<Page*>(chunk);
   MemoryChunk::Initialize(heap,
                           reinterpret_cast<Address>(chunk),
                           kPageSize,
                           executable,
                           owner);
   owner->IncreaseCapacity(Page::kObjectAreaSize);
   owner->Free(page->ObjectAreaStart(),
               page->ObjectAreaEnd() - page->ObjectAreaStart());
+
+  heap->incremental_marking()->SetOldSpacePageFlags(chunk);
+
   return page;
 }
 
 
 bool PagedSpace::Contains(Address addr) {
   Page* p = Page::FromAddress(addr);
   if (!p->is_valid()) return false;
   return p->owner() == this;
 }
 
 
 void MemoryChunk::set_scan_on_scavenge(bool scan) {
   if (scan) {
-    if (!scan_on_scavenge_) heap_->increment_scan_on_scavenge_pages();
+    if (!scan_on_scavenge()) heap_->increment_scan_on_scavenge_pages();
+    SetFlag(SCAN_ON_SCAVENGE);
   } else {
-    if (scan_on_scavenge_) heap_->decrement_scan_on_scavenge_pages();
+    if (scan_on_scavenge()) heap_->decrement_scan_on_scavenge_pages();
+    ClearFlag(SCAN_ON_SCAVENGE);
   }
-  scan_on_scavenge_ = scan;
+  heap_->incremental_marking()->SetOldSpacePageFlags(this);
 }
 
 
 MemoryChunk* MemoryChunk::FromAnyPointerAddress(Address addr) {
   MemoryChunk* maybe = reinterpret_cast<MemoryChunk*>(
       OffsetFrom(addr) & ~Page::kPageAlignmentMask);
   if (maybe->owner() != NULL) return maybe;
   // TODO(gc) ISOLATESMERGE HEAP
   LargeObjectIterator iterator(HEAP->lo_space());
   for (HeapObject* o = iterator.next(); o != NULL; o = iterator.next()) {
@@ skipping 104 matching lines @@
   }
 
   Object* obj = HeapObject::FromAddress(allocation_info_.top);
   allocation_info_.top = new_top;
   ASSERT_SEMISPACE_ALLOCATION_INFO(allocation_info_, to_space_);
 
   return obj;
 }
 
 
+LargePage* LargePage::Initialize(Heap* heap, MemoryChunk* chunk) {
+  // TODO(gc) ISOLATESMERGE initialize chunk to point to heap?

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

I don't see how we can defer this to a TODO.  We have GetHeap that works on any
HeapObject.  This will fail if we get a large object.

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

Done.

+  heap->incremental_marking()->SetOldSpacePageFlags(chunk);
+  return static_cast<LargePage*>(chunk);
+}
+
+
 intptr_t LargeObjectSpace::Available() {
   return ObjectSizeFor(heap()->isolate()->memory_allocator()->Available());
 }
 
 
 template <typename StringType>
 void NewSpace::ShrinkStringAtAllocationBoundary(String* string, int length) {
   ASSERT(length <= string->length());
   ASSERT(string->IsSeqString());
   ASSERT(string->address() + StringType::SizeFor(string->length()) ==
          allocation_info_.top);
   allocation_info_.top =
       string->address() + StringType::SizeFor(length);
   string->set_length(length);
 }
 
 
 bool FreeListNode::IsFreeListNode(HeapObject* object) {
   // TODO(gc) ISOLATES MERGE
   return object->map() == HEAP->raw_unchecked_free_space_map()
       || object->map() == HEAP->raw_unchecked_one_pointer_filler_map()
       || object->map() == HEAP->raw_unchecked_two_pointer_filler_map();
 }
 
 } }  // namespace v8::internal
 
 #endif  // V8_SPACES_INL_H_