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

src/heap.h

 // Copyright 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 196 matching lines @@
 
 
 // Forward declarations.
 class GCTracer;
 class HeapStats;
 class WeakObjectRetainer;
 
 
 typedef String* (*ExternalStringTableUpdaterCallback)(Object** pointer);
 
-typedef bool (*DirtyRegionCallback)(Address start,
-                                    Address end,
-                                    ObjectSlotCallback copy_object_func);
+typedef void (*PointerRegionCallback)(Address start,
+                                      Address end,
+                                      ObjectSlotCallback copy_object_func);
 
 
 // The all static Heap captures the interface to the global object heap.
 // All JavaScript contexts by this process share the same object heap.
 
 class Heap : public AllStatic {
  public:
   // Configure heap size before setup. Return false if the heap has been
   // setup already.
   static bool ConfigureHeap(intptr_t max_semispace_size,
@@ skipping 584 matching lines @@
   // Iterates over all strong roots in the heap.
   static void IterateStrongRoots(ObjectVisitor* v, VisitMode mode);
   // Iterates over all the other roots in the heap.
   static void IterateWeakRoots(ObjectVisitor* v, VisitMode mode);
 
   enum ExpectedPageWatermarkState {
     WATERMARK_SHOULD_BE_VALID,
     WATERMARK_CAN_BE_INVALID
   };
 
-  // For each dirty region on a page in use from an old space call
-  // visit_dirty_region callback.
-  // If either visit_dirty_region or callback can cause an allocation
+  // For each region of pointers on a page in use from an old space call
+  // visit_pointer_region callback.
+  // If either visit_pointer_region or callback can cause an allocation
   // in old space and changes in allocation watermark then
   // can_preallocate_during_iteration should be set to true.
   // All pages will be marked as having invalid watermark upon
   // iteration completion.
-  static void IterateDirtyRegions(
+  static void IteratePointers(
       PagedSpace* space,
-      DirtyRegionCallback visit_dirty_region,
+      PointerRegionCallback visit_pointer_region,
       ObjectSlotCallback callback,
       ExpectedPageWatermarkState expected_page_watermark_state);
 
-  // Interpret marks as a bitvector of dirty marks for regions of size
-  // Page::kRegionSize aligned by Page::kRegionAlignmentMask and covering
-  // memory interval from start to top. For each dirty region call a
-  // visit_dirty_region callback. Return updated bitvector of dirty marks.
-  static uint32_t IterateDirtyRegions(uint32_t marks,
-                                      Address start,
-                                      Address end,
-                                      DirtyRegionCallback visit_dirty_region,
-                                      ObjectSlotCallback callback);
-
   // Iterate pointers to from semispace of new space found in memory interval
   // from start to end.
-  // Update dirty marks for page containing start address.
   static void IterateAndMarkPointersToFromSpace(Address start,
                                                 Address end,
                                                 ObjectSlotCallback callback);
 
   // Iterate pointers to new space found in memory interval from start to end.
-  // Return true if pointers to new space was found.
-  static bool IteratePointersInDirtyRegion(Address start,
-                                           Address end,
-                                           ObjectSlotCallback callback);
+  static void IteratePointersToNewSpace(Address start,
+                                        Address end,
+                                        ObjectSlotCallback callback);
 
 
   // Iterate pointers to new space found in memory interval from start to end.
   // This interval is considered to belong to the map space.
-  // Return true if pointers to new space was found.
-  static bool IteratePointersInDirtyMapsRegion(Address start,
-                                               Address end,
-                                               ObjectSlotCallback callback);
+  static void IteratePointersFromMapsToNewSpace(Address start,
+                                                Address end,
+                                                ObjectSlotCallback callback);
 
 
   // Returns whether the object resides in new space.
   static inline bool InNewSpace(Object* object);
   static inline bool InNewSpace(Address addr);
   static inline bool InFromSpace(Object* object);
   static inline bool InToSpace(Object* object);
 
   // Checks whether an address/object in the heap (including auxiliary
   // area and unused area).
@@ skipping 634 matching lines @@
   void VisitPointers(Object** start, Object** end) {
     for (Object** current = start; current < end; current++) {
       if ((*current)->IsHeapObject()) {
         HeapObject* object = HeapObject::cast(*current);
         ASSERT(Heap::Contains(object));
         ASSERT(object->map()->IsMap());
       }
     }
   }
 };
-
-
-#ifdef ENABLE_CARDMARKING_WRITE_BARRIER
-// Visitor class to verify interior pointers in spaces that use region marks
-// to keep track of intergenerational references.
-// As VerifyPointersVisitor but also checks that dirty marks are set
-// for regions covering intergenerational references.
-class VerifyPointersAndDirtyRegionsVisitor: public ObjectVisitor {
- public:
-  void VisitPointers(Object** start, Object** end) {
-    for (Object** current = start; current < end; current++) {
-      if ((*current)->IsHeapObject()) {
-        HeapObject* object = HeapObject::cast(*current);
-        ASSERT(Heap::Contains(object));
-        ASSERT(object->map()->IsMap());
-        if (Heap::InNewSpace(object)) {
-          ASSERT(Heap::InToSpace(object));
-          Address addr = reinterpret_cast<Address>(current);
-          ASSERT(Page::FromAddress(addr)->IsRegionDirty(addr));
-        }
-      }
-    }
-  }
-};
 #endif
-#endif
 
 
 // Space iterator for iterating over all spaces of the heap.
 // Returns each space in turn, and null when it is done.
 class AllSpaces BASE_EMBEDDED {
  public:
   Space* next();
   AllSpaces() { counter_ = FIRST_SPACE; }
  private:
   int counter_;
@@ skipping 610 matching lines @@
 
  private:
   static const uintptr_t kNotMarkedBit = 0x1;
   STATIC_ASSERT((kHeapObjectTag & kNotMarkedBit) != 0);
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_HEAP_H_