Make the store buffer smaller and handle store buffer

src/store-buffer.cc

 // 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 377 matching lines @@
       }
     }
   }
 }
 #endif
 
 
 void StoreBuffer::Verify() {
 #ifdef DEBUG
   VerifyPointers(heap_->old_pointer_space(),
-                 &StoreBuffer::FindPointersToNewSpaceInRegion);
+                 &StoreBuffer::FindPointersToNewSpaceInRegionDontRecord);
   VerifyPointers(heap_->map_space(),
                  &StoreBuffer::FindPointersToNewSpaceInMapsRegion);
   VerifyPointers(heap_->lo_space());
 #endif
 }
 
 
 void StoreBuffer::GCEpilogue(GCType type, GCCallbackFlags flags) {
   // TODO(gc) ISOLATES MERGE
   HEAP->store_buffer()->during_gc_ = false;
   HEAP->store_buffer()->Verify();
 }
 
 
+template<StoreBuffer::RecordNewSpacePointers record>
 void StoreBuffer::FindPointersToNewSpaceInRegion(
     Address start, Address end, ObjectSlotCallback slot_callback) {
   for (Address slot_address = start;
        slot_address < end;
        slot_address += kPointerSize) {
     Object** slot = reinterpret_cast<Object**>(slot_address);
     if (heap_->InNewSpace(*slot)) {
       HeapObject* object = reinterpret_cast<HeapObject*>(*slot);
       ASSERT(object->IsHeapObject());
       slot_callback(reinterpret_cast<HeapObject**>(slot), object);
-      if (heap_->InNewSpace(*slot)) {
-        EnterDirectlyIntoStoreBuffer(slot_address);
+      if (record == kRecord) {
+        if (heap_->InNewSpace(*slot)) {
+          EnterDirectlyIntoStoreBuffer(slot_address);
+        }
       }
     }
   }
 }
 
 
+void StoreBuffer::FindPointersToNewSpaceInRegionRecord(
+    StoreBuffer* store_buffer,
+    Address start,
+    Address end,
+    ObjectSlotCallback slot_callback) {
+  store_buffer->FindPointersToNewSpaceInRegion<kRecord>(
+      start, end, slot_callback);
+}
+
+
+void StoreBuffer::FindPointersToNewSpaceInRegionDontRecord(
+    StoreBuffer* store_buffer,
+    Address start,
+    Address end,
+    ObjectSlotCallback slot_callback) {
+  store_buffer->FindPointersToNewSpaceInRegion<kDontRecord>(
+      start, end, slot_callback);
+}
+
+
 // Compute start address of the first map following given addr.
 static inline Address MapStartAlign(Address addr) {
   Address page = Page::FromAddress(addr)->ObjectAreaStart();
   return page + (((addr - page) + (Map::kSize - 1)) / Map::kSize * Map::kSize);
 }
 
 
 // Compute end address of the first map preceding given addr.
 static inline Address MapEndAlign(Address addr) {
   Address page = Page::FromAllocationTop(addr)->ObjectAreaStart();
   return page + ((addr - page) / Map::kSize * Map::kSize);
 }
 
 
 void StoreBuffer::FindPointersToNewSpaceInMaps(
     Address start,
     Address end,
     ObjectSlotCallback slot_callback) {
   ASSERT(MapStartAlign(start) == start);
   ASSERT(MapEndAlign(end) == end);
 
   Address map_address = start;
   while (map_address < end) {
     ASSERT(!heap_->InNewSpace(Memory::Object_at(map_address)));
     ASSERT(Memory::Object_at(map_address)->IsMap());
 
     Address pointer_fields_start = map_address + Map::kPointerFieldsBeginOffset;
     Address pointer_fields_end = map_address + Map::kPointerFieldsEndOffset;
 
-    FindPointersToNewSpaceInRegion(pointer_fields_start,
-                                   pointer_fields_end,
-                                   slot_callback);
+    FindPointersToNewSpaceInRegion<kRecord>(pointer_fields_start,
+                                            pointer_fields_end,
+                                            slot_callback);
     map_address += Map::kSize;
   }
 }
 
 
 void StoreBuffer::FindPointersToNewSpaceInMapsRegion(
+    StoreBuffer* store_buffer,
     Address start,
     Address end,
     ObjectSlotCallback slot_callback) {
   Address map_aligned_start = MapStartAlign(start);
   Address map_aligned_end   = MapEndAlign(end);
 
   ASSERT(map_aligned_start == start);
   ASSERT(map_aligned_end == end);
 
-  FindPointersToNewSpaceInMaps(map_aligned_start,
-                               map_aligned_end,
-                               slot_callback);
+  store_buffer->FindPointersToNewSpaceInMaps(map_aligned_start,
+                                             map_aligned_end,
+                                             slot_callback);
 }
 
 
 // This function iterates over all the pointers in a paged space in the heap,
 // looking for pointers into new space.  Within the pages there may be dead
 // objects that have not been overwritten by free spaces or fillers because of
 // lazy sweeping.  These dead objects may not contain pointers to new space.
 // The garbage areas that have been swept properly (these will normally be the
 // large ones) will be marked with free space and filler map words.  In
 // addition any area that has never been used at all for object allocation must
@@ skipping 19 matching lines @@
 
   while (visitable_end < end_of_page) {
     Object* o = *reinterpret_cast<Object**>(visitable_end);
     // Skip fillers but not things that look like fillers in the special
     // garbage section which can contain anything.
     if (o == free_space_map ||
         o == two_pointer_filler_map ||
         visitable_end == space->top()) {
       if (visitable_start != visitable_end) {
         // After calling this the special garbage section may have moved.
-        (this->*region_callback)(visitable_start,
-                                 visitable_end,
-                                 slot_callback);
+        (*region_callback)(this,
+                           visitable_start,
+                           visitable_end,
+                           slot_callback);
         if (visitable_end >= space->top() && visitable_end < space->limit()) {
           visitable_end = space->limit();
           visitable_start = visitable_end;
           continue;
         }
       }
       if (visitable_end == space->top() && visitable_end != space->limit()) {
         visitable_start = visitable_end = space->limit();
       } else {
         // At this point we are either at the start of a filler or we are at
         // the point where the space->top() used to be before the
         // visit_pointer_region call above.  Either way we can skip the
         // object at the current spot:  We don't promise to visit objects
         // allocated during heap traversal, and if space->top() moved then it
         // must be because an object was allocated at this point.
         visitable_start =
             visitable_end + HeapObject::FromAddress(visitable_end)->Size();
         visitable_end = visitable_start;
       }
     } else {
       ASSERT(o != free_space_map);
       ASSERT(o != two_pointer_filler_map);
       ASSERT(visitable_end < space->top() || visitable_end >= space->limit());
       visitable_end += kPointerSize;
     }
   }
   ASSERT(visitable_end == end_of_page);
   if (visitable_start != visitable_end) {
-    (this->*region_callback)(visitable_start,
-                             visitable_end,
-                             slot_callback);
+    (*region_callback)(this,
+                       visitable_start,
+                       visitable_end,
+                       slot_callback);
   }
 }
 
 
 void StoreBuffer::IteratePointersInStoreBuffer(
     ObjectSlotCallback slot_callback) {
   Address* limit = old_top_;
   old_top_ = old_start_;
   {
     DontMoveStoreBufferEntriesScope scope(this);
@@ skipping 47 matching lines @@
         chunk->set_scan_on_scavenge(false);
         if (callback_ != NULL) {
           (*callback_)(heap_, chunk, kStoreBufferScanningPageEvent);
         }
         if (chunk->owner() == heap_->lo_space()) {
           LargePage* large_page = reinterpret_cast<LargePage*>(chunk);
           HeapObject* array = large_page->GetObject();
           ASSERT(array->IsFixedArray());
           Address start = array->address();
           Address end = start + array->Size();
-          FindPointersToNewSpaceInRegion(start, end, slot_callback);
+          const int kLump = 10000;
+          for (Address current = start; current < end; current += kLump) {
+            if (chunk->scan_on_scavenge()) {
+              FindPointersToNewSpaceInRegion<kDontRecord>(
+                  current,
+                  Min(end, current + kLump),
+                  slot_callback);
+            } else {
+              FindPointersToNewSpaceInRegion<kRecord>(
+                  current,
+                  Min(end, current + kLump),
+                  slot_callback);
+            }
+          }
         } else {
           Page* page = reinterpret_cast<Page*>(chunk);
           PagedSpace* owner = reinterpret_cast<PagedSpace*>(page->owner());
           FindPointersToNewSpaceOnPage(
               owner,
               page,
               (owner == heap_->map_space() ?
                  &StoreBuffer::FindPointersToNewSpaceInMapsRegion :
-                 &StoreBuffer::FindPointersToNewSpaceInRegion),
+                 &StoreBuffer::FindPointersToNewSpaceInRegionRecord),
               slot_callback);
         }
       }
     }
     (*callback_)(heap_, NULL, kStoreBufferScanningPageEvent);
   }
 }
 
 
 void StoreBuffer::Compact() {
@@ skipping 47 matching lines @@
 }
 
 
 void StoreBuffer::CheckForFullBuffer() {
   if (old_limit_ - old_top_ < kStoreBufferSize * 2) {
     HandleFullness();
   }
 }
 
 } }  // namespace v8::internal