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

src/heap-inl.h

 // 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 322 matching lines @@
 
 
 void Heap::CopyBlockToOldSpaceAndUpdateWriteBarrier(Address dst,
                                                     Address src,
                                                     int byte_size) {
   ASSERT(IsAligned(byte_size, kPointerSize));
 
   for (int remaining = byte_size / kPointerSize;
        remaining > 0;
        remaining--) {
-    Memory::Object_at(dst) = Memory::Object_at(src);
+    Object* data = Memory::Object_at(src);
+    Memory::Object_at(dst) = data;

[Vyacheslav Egorov (Chromium), 2011/02/02 13:15:47]

revert please

[Erik Corry, 2011/02/03 13:21:17]

Done.

 
     if (Heap::InNewSpace(Memory::Object_at(dst))) {
       StoreBuffer::Mark(dst);
     }
 
     dst += kPointerSize;
     src += kPointerSize;
   }
 }
 
@@ skipping 26 matching lines @@
 
   // We use the first word (where the map pointer usually is) of a heap
   // object to record the forwarding pointer.  A forwarding pointer can
   // point to an old space, the code space, or the to space of the new
   // generation.
   MapWord first_word = object->map_word();
 
   // If the first word is a forwarding address, the object has already been
   // copied.
   if (first_word.IsForwardingAddress()) {
-    *p = first_word.ToForwardingAddress();
+    HeapObject* dest = first_word.ToForwardingAddress();
+    *p = dest;
+    Address cell = reinterpret_cast<Address>(p);

[Vyacheslav Egorov (Chromium), 2011/02/02 13:15:47]

cell is a bit confusing cause we have cell_space and cells.

I usually call them slots.

[Erik Corry, 2011/02/03 13:21:17]

Done.

+    if (Heap::InNewSpace(dest) && !Heap::InNewSpace(cell)) {
+      StoreBuffer::EnterDirectlyIntoStoreBuffer(cell);
+    }
     return;
   }
 
   // Call the slow part of scavenge object.
   return ScavengeObjectSlow(p, object);
 }
 
 
 bool Heap::CollectGarbage(AllocationSpace space) {
   return CollectGarbage(space, SelectGarbageCollector(space));
@@ skipping 169 matching lines @@
 
 
 void ExternalStringTable::ShrinkNewStrings(int position) {
   new_space_strings_.Rewind(position);
   Verify();
 }
 
 } }  // namespace v8::internal
 
 #endif  // V8_HEAP_INL_H_