On store buffer overflow we mark individidual pages for...

src/heap.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 17 matching lines @@
 #ifndef V8_HEAP_H_
 #define V8_HEAP_H_
 
 #include <math.h>
 
 #include "globals.h"
 #include "list.h"
 #include "spaces.h"
 #include "splay-tree-inl.h"
 #include "v8-counters.h"
+#include "v8globals.h"
 
 namespace v8 {
 namespace internal {
 
 
 // Defines all the roots in Heap.
 #define STRONG_ROOT_LIST(V)                                      \
   V(Map, byte_array_map, ByteArrayMap)                                         \
   V(Map, free_space_map, FreeSpaceMap)                                         \
   V(Map, one_pointer_filler_map, OnePointerFillerMap)                          \
@@ skipping 180 matching lines @@
 class WeakObjectRetainer;
 
 
 typedef String* (*ExternalStringTableUpdaterCallback)(Object** pointer);
 
 typedef void (*PointerRegionCallback)(Address start,
                                       Address end,
                                       ObjectSlotCallback copy_object_func);
 
 
+class StoreBufferRebuilder : public AllStatic {
+ public:
+  void Callback(MemoryChunk* page, StoreBufferEvent event);
+
+ private:
+  // The fullness of the store buffer when we started to scan the current page.

[Vyacheslav Egorov (Chromium), 2011/03/28 15:13:19]

I can't grok the comment.

[Erik Corry, 2011/03/28 15:56:07]

Rewritten.

+  Object*** start_of_current_page_;
+  // The current page we are scanning in the store buffer iterator.
+  MemoryChunk* current_page_;
+};
+
+
+
 // 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,
                             intptr_t max_old_gen_size,
                             intptr_t max_executable_size);
@@ skipping 596 matching lines @@
   }
   static Object* global_contexts_list() { return global_contexts_list_; }
 
   // Iterates over all roots in the heap.
   static void IterateRoots(ObjectVisitor* v, VisitMode mode);
   // 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 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 IteratePointers(
       PagedSpace* space,
       PointerRegionCallback visit_pointer_region,
+      ObjectSlotCallback callback);
+  static void IteratePointersOnPage(
+      PagedSpace* space,
+      PointerRegionCallback visit_pointer_region,
       ObjectSlotCallback callback,
-      ExpectedPageWatermarkState expected_page_watermark_state);
+      Page* page);
 
   // Iterate pointers to from semispace of new space found in memory interval
   // from start to end.
   static void IterateAndMarkPointersToFromSpace(Address start,
                                                 Address end,
                                                 ObjectSlotCallback callback);
 
   // Iterate pointers to new space found in memory interval from start to end.
   static void IteratePointersToNewSpace(Address start,
                                         Address end,
@@ skipping 67 matching lines @@
     return &global_contexts_list_;
   }
 
 #ifdef DEBUG
   static void Print();
   static void PrintHandles();
 
   // Verify the heap is in its normal state before or after a GC.
   static void Verify();
 
-  static void OldPointerSpaceCheckStoreBuffer(
-      ExpectedPageWatermarkState watermark_state);
-  static void MapSpaceCheckStoreBuffer(
-      ExpectedPageWatermarkState watermark_state);
+  static void OldPointerSpaceCheckStoreBuffer();
+  static void MapSpaceCheckStoreBuffer();
   static void LargeObjectSpaceCheckStoreBuffer();
 
   // Report heap statistics.
   static void ReportHeapStatistics(const char* title);
   static void ReportCodeStatistics(const char* title);
 
   // Fill in bogus values in from space
   static void ZapFromSpace();
 #endif
 
@@ skipping 86 matching lines @@
       int length,
       PretenureFlag pretenure);
 
   // True if we have reached the allocation limit in the old generation that
   // should force the next GC (caused normally) to be a full one.
   static bool OldGenerationPromotionLimitReached() {
     return (PromotedSpaceSize() + PromotedExternalMemorySize())
            > old_gen_promotion_limit_;
   }
 
-  static intptr_t OldGenerationSpaceAvailable() {
+  static inline intptr_t OldGenerationSpaceAvailable() {
     return old_gen_allocation_limit_ -
            (PromotedSpaceSize() + PromotedExternalMemorySize());
   }
 
   // True if we have reached the allocation limit in the old generation that
   // should artificially cause a GC right now.
-  static bool OldGenerationAllocationLimitReached() {
-    return OldGenerationSpaceAvailable() < 0;
-  }
+  static inline bool OldGenerationAllocationLimitReached();
 
   // Can be called when the embedding application is idle.
   static bool IdleNotification();
 
   // Declare all the root indices.
   enum RootListIndex {
 #define ROOT_INDEX_DECLARATION(type, name, camel_name) k##camel_name##RootIndex,
     STRONG_ROOT_LIST(ROOT_INDEX_DECLARATION)
 #undef ROOT_INDEX_DECLARATION
 
@@ skipping 176 matching lines @@
   static int amount_of_external_allocated_memory_at_last_global_gc_;
 
   // Indicates that an allocation has failed in the old generation since the
   // last GC.
   static int old_gen_exhausted_;
 
   static Object* roots_[kRootListLength];
 
   static Object* global_contexts_list_;
 
+  static StoreBufferRebuilder store_buffer_rebuilder_;
+
   struct StringTypeTable {
     InstanceType type;
     int size;
     RootListIndex index;
   };
 
   struct ConstantSymbolTable {
     const char* contents;
     RootListIndex index;
   };
@@ skipping 91 matching lines @@
   MUST_USE_RESULT static MaybeObject* AllocateEmptyFixedArray();
 
   // Performs a minor collection in new generation.
   static void Scavenge();
 
   static String* UpdateNewSpaceReferenceInExternalStringTableEntry(
       Object** pointer);
 
   static Address DoScavenge(ObjectVisitor* scavenge_visitor,
                             Address new_space_front);
+  static void ScavengeStoreBufferCallback(MemoryChunk* page,
+                                          StoreBufferEvent event);
 
   // Performs a major collection in the whole heap.
   static void MarkCompact(GCTracer* tracer);
 
   // Code to be run before and after mark-compact.
   static void MarkCompactPrologue(bool is_compacting);
 
   // Completely clear the Instanceof cache (to stop it keeping objects alive
   // around a GC).
   static void CompletelyClearInstanceofCache() {
@@ skipping 855 matching lines @@
 
   AssertNoAllocation no_alloc;  // i.e. no gc allowed.
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(PathTracer);
 };
 #endif  // DEBUG || LIVE_OBJECT_LIST
 
 } }  // namespace v8::internal
 
 #endif  // V8_HEAP_H_