Start using store buffers. Handle store buffer overflow situation....

src/spaces.cc

 // Copyright 2006-2010 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 1699 matching lines @@
   ASSERT(bytes <= InitialCapacity());
   Address limit = allocation_info_.limit;
   Address top = allocation_info_.top;
   return limit - top >= bytes;
 }
 
 
 void PagedSpace::FreePages(Page* prev, Page* last) {
   if (last == AllocationTopPage()) {
     // Pages are already at the end of used pages.
-    // Just mark them as continuos.
+    // Just mark them as continuous.
     Page* p = prev == NULL ? first_page_ : prev->next_page();
     Page* end_page = last->next_page();
     do {
       p->SetFlag(Page::IS_CONTINUOUS);
       p = p->next_page();
     } while (p != end_page);
     return;
   }
 
   Page* first = NULL;
@@ skipping 10 matching lines @@
   // Attach it after the last page.
   last_page_->set_next_page(first);
   last_page_ = last;
   last->set_next_page(NULL);
 
   // Clean them up.
   do {
     first->InvalidateWatermark(true);
     first->SetAllocationWatermark(first->ObjectAreaStart());
     first->SetCachedAllocationWatermark(first->ObjectAreaStart());
-    first->SetRegionMarks(Page::kAllRegionsCleanMarks);
     first->SetFlag(Page::IS_CONTINUOUS);
     first->markbits()->Clear();
     first = first->next_page();
   } while (first->is_valid());
 }
 
 
 void PagedSpace::PrepareForMarkCompact(bool will_compact) {
   ASSERT(!will_compact);
 }
@@ skipping 592 matching lines @@
        chunk = chunk->next_page()) {
     Address chunk_address = chunk->address();
     if (chunk_address <= pc && pc < chunk_address + chunk->size()) {
       return chunk;
     }
   }
   return NULL;
 }
 
 
-void LargeObjectSpace::IterateDirtyRegions(ObjectSlotCallback copy_object) {
+void LargeObjectSpace::IteratePointersToNewSpace(
+    ObjectSlotCallback copy_object) {
   LargeObjectIterator it(this);
   for (HeapObject* object = it.next(); object != NULL; object = it.next()) {
     // We only have code, sequential strings, or fixed arrays in large
     // object space, and only fixed arrays can possibly contain pointers to
     // the young generation.
     if (object->IsFixedArray()) {
       // TODO(gc): we can no longer assume that LargePage is bigger than normal
       // page.
 
       Address start = object->address();
       Address object_end = start + object->Size();
-      Heap::IteratePointersInDirtyRegion(start, object_end, copy_object);
+      Heap::IteratePointersToNewSpace(start, object_end, copy_object);
     }
   }
 }
 
 
 void LargeObjectSpace::FreeUnmarkedObjects() {
   LargePage* previous = NULL;
   LargePage* current = first_page_;
   while (current != NULL) {
     HeapObject* object = current->GetObject();
@@ skipping 69 matching lines @@
     // The object itself should look OK.
     object->Verify();
 
     // Byte arrays and strings don't have interior pointers.
     if (object->IsCode()) {
       VerifyPointersVisitor code_visitor;
       object->IterateBody(map->instance_type(),
                           object->Size(),
                           &code_visitor);
     } else if (object->IsFixedArray()) {
-      // We loop over fixed arrays ourselves, rather then using the visitor,
-      // because the visitor doesn't support the start/offset iteration
-      // needed for IsRegionDirty.
       FixedArray* array = FixedArray::cast(object);
       for (int j = 0; j < array->length(); j++) {
         Object* element = array->get(j);
         if (element->IsHeapObject()) {
           HeapObject* element_object = HeapObject::cast(element);
           ASSERT(Heap::Contains(element_object));
           ASSERT(element_object->map()->IsMap());
-          if (Heap::InNewSpace(element_object)) {
-            Address array_addr = object->address();
-            Address element_addr = array_addr + FixedArray::kHeaderSize +
-                j * kPointerSize;
-
-            ASSERT(Page::FromAddress(array_addr)->IsRegionDirty(element_addr));
-          }
         }
       }
     }
   }
 }
 
 
 void LargeObjectSpace::Print() {
   LargeObjectIterator it(this);
   for (HeapObject* obj = it.next(); obj != NULL; obj = it.next()) {
@@ skipping 23 matching lines @@
   for (HeapObject* obj = obj_it.next(); obj != NULL; obj = obj_it.next()) {
     if (obj->IsCode()) {
       Code* code = Code::cast(obj);
       code_kind_statistics[code->kind()] += code->Size();
     }
   }
 }
 #endif  // DEBUG
 
 } }  // namespace v8::internal