src/v8/src/incremental-marking.h

   1 // Copyright 2012 the V8 project authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef V8_INCREMENTAL_MARKING_H_
   6 #define V8_INCREMENTAL_MARKING_H_
   7
   8
   9 #include "execution.h"
  10 #include "mark-compact.h"
  11 #include "objects.h"
  12
  13 namespace v8 {
  14 namespace internal {
  15
  16
  17 class IncrementalMarking {
  18  public:
  19   enum State {
  20     STOPPED,
  21     SWEEPING,
  22     MARKING,
  23     COMPLETE
  24   };
  25
  26   enum CompletionAction {
  27     GC_VIA_STACK_GUARD,
  28     NO_GC_VIA_STACK_GUARD
  29   };
  30
  31   explicit IncrementalMarking(Heap* heap);
  32
  33   static void Initialize();
  34
  35   void TearDown();
  36
  37   State state() {
  38     ASSERT(state_ == STOPPED || FLAG_incremental_marking);
  39     return state_;
  40   }
  41
  42   bool should_hurry() { return should_hurry_; }
  43   void set_should_hurry(bool val) { should_hurry_ = val; }
  44
  45   inline bool IsStopped() { return state() == STOPPED; }
  46
  47   INLINE(bool IsMarking()) { return state() >= MARKING; }
  48
  49   inline bool IsMarkingIncomplete() { return state() == MARKING; }
  50
  51   inline bool IsComplete() { return state() == COMPLETE; }
  52
  53   bool WorthActivating();
  54
  55   enum CompactionFlag { ALLOW_COMPACTION, PREVENT_COMPACTION };
  56
  57   void Start(CompactionFlag flag = ALLOW_COMPACTION);
  58
  59   void Stop();
  60
  61   void PrepareForScavenge();
  62
  63   void UpdateMarkingDequeAfterScavenge();
  64
  65   void Hurry();
  66
  67   void Finalize();
  68
  69   void Abort();
  70
  71   void MarkingComplete(CompletionAction action);
  72
  73   // It's hard to know how much work the incremental marker should do to make
  74   // progress in the face of the mutator creating new work for it.  We start
  75   // of at a moderate rate of work and gradually increase the speed of the
  76   // incremental marker until it completes.
  77   // Do some marking every time this much memory has been allocated or that many
  78   // heavy (color-checking) write barriers have been invoked.
  79   static const intptr_t kAllocatedThreshold = 65536;
  80   static const intptr_t kWriteBarriersInvokedThreshold = 32768;
  81   // Start off by marking this many times more memory than has been allocated.
  82   static const intptr_t kInitialMarkingSpeed = 1;
  83   // But if we are promoting a lot of data we need to mark faster to keep up
  84   // with the data that is entering the old space through promotion.
  85   static const intptr_t kFastMarking = 3;
  86   // After this many steps we increase the marking/allocating factor.
  87   static const intptr_t kMarkingSpeedAccellerationInterval = 1024;
  88   // This is how much we increase the marking/allocating factor by.
  89   static const intptr_t kMarkingSpeedAccelleration = 2;
  90   static const intptr_t kMaxMarkingSpeed = 1000;
  91
  92   void OldSpaceStep(intptr_t allocated);
  93
  94   void Step(intptr_t allocated, CompletionAction action);
  95
  96   inline void RestartIfNotMarking() {
  97     if (state_ == COMPLETE) {
  98       state_ = MARKING;
  99       if (FLAG_trace_incremental_marking) {
 100         PrintF("[IncrementalMarking] Restarting (new grey objects)\n");
 101       }
 102     }
 103   }
 104
 105   static void RecordWriteFromCode(HeapObject* obj,
 106                                   Object** slot,
 107                                   Isolate* isolate);
 108
 109   // Record a slot for compaction.  Returns false for objects that are
 110   // guaranteed to be rescanned or not guaranteed to survive.
 111   //
 112   // No slots in white objects should be recorded, as some slots are typed and
 113   // cannot be interpreted correctly if the underlying object does not survive
 114   // the incremental cycle (stays white).
 115   INLINE(bool BaseRecordWrite(HeapObject* obj, Object** slot, Object* value));
 116   INLINE(void RecordWrite(HeapObject* obj, Object** slot, Object* value));
 117   INLINE(void RecordWriteIntoCode(HeapObject* obj,
 118                                   RelocInfo* rinfo,
 119                                   Object* value));
 120   INLINE(void RecordWriteOfCodeEntry(JSFunction* host,
 121                                      Object** slot,
 122                                      Code* value));
 123
 124
 125   void RecordWriteSlow(HeapObject* obj, Object** slot, Object* value);
 126   void RecordWriteIntoCodeSlow(HeapObject* obj,
 127                                RelocInfo* rinfo,
 128                                Object* value);
 129   void RecordWriteOfCodeEntrySlow(JSFunction* host, Object** slot, Code* value);
 130   void RecordCodeTargetPatch(Code* host, Address pc, HeapObject* value);
 131   void RecordCodeTargetPatch(Address pc, HeapObject* value);
 132
 133   inline void RecordWrites(HeapObject* obj);
 134
 135   inline void BlackToGreyAndUnshift(HeapObject* obj, MarkBit mark_bit);
 136
 137   inline void WhiteToGreyAndPush(HeapObject* obj, MarkBit mark_bit);
 138
 139   inline int steps_count() {
 140     return steps_count_;
 141   }
 142
 143   inline double steps_took() {
 144     return steps_took_;
 145   }
 146
 147   inline double longest_step() {
 148     return longest_step_;
 149   }
 150
 151   inline int steps_count_since_last_gc() {
 152     return steps_count_since_last_gc_;
 153   }
 154
 155   inline double steps_took_since_last_gc() {
 156     return steps_took_since_last_gc_;
 157   }
 158
 159   inline void SetOldSpacePageFlags(MemoryChunk* chunk) {
 160     SetOldSpacePageFlags(chunk, IsMarking(), IsCompacting());
 161   }
 162
 163   inline void SetNewSpacePageFlags(NewSpacePage* chunk) {
 164     SetNewSpacePageFlags(chunk, IsMarking());
 165   }
 166
 167   MarkingDeque* marking_deque() { return &marking_deque_; }
 168
 169   bool IsCompacting() { return IsMarking() && is_compacting_; }
 170
 171   void ActivateGeneratedStub(Code* stub);
 172
 173   void NotifyOfHighPromotionRate() {
 174     if (IsMarking()) {
 175       if (marking_speed_ < kFastMarking) {
 176         if (FLAG_trace_gc) {
 177           PrintPID("Increasing marking speed to %d "
 178                    "due to high promotion rate\n",
 179                    static_cast<int>(kFastMarking));
 180         }
 181         marking_speed_ = kFastMarking;
 182       }
 183     }
 184   }
 185
 186   void EnterNoMarkingScope() {
 187     no_marking_scope_depth_++;
 188   }
 189
 190   void LeaveNoMarkingScope() {
 191     no_marking_scope_depth_--;
 192   }
 193
 194   void UncommitMarkingDeque();
 195
 196   void NotifyIncompleteScanOfObject(int unscanned_bytes) {
 197     unscanned_bytes_of_large_object_ = unscanned_bytes;
 198   }
 199
 200  private:
 201   int64_t SpaceLeftInOldSpace();
 202
 203   void ResetStepCounters();
 204
 205   void StartMarking(CompactionFlag flag);
 206
 207   void ActivateIncrementalWriteBarrier(PagedSpace* space);
 208   static void ActivateIncrementalWriteBarrier(NewSpace* space);
 209   void ActivateIncrementalWriteBarrier();
 210
 211   static void DeactivateIncrementalWriteBarrierForSpace(PagedSpace* space);
 212   static void DeactivateIncrementalWriteBarrierForSpace(NewSpace* space);
 213   void DeactivateIncrementalWriteBarrier();
 214
 215   static void SetOldSpacePageFlags(MemoryChunk* chunk,
 216                                    bool is_marking,
 217                                    bool is_compacting);
 218
 219   static void SetNewSpacePageFlags(NewSpacePage* chunk, bool is_marking);
 220
 221   void EnsureMarkingDequeIsCommitted();
 222
 223   INLINE(void ProcessMarkingDeque());
 224
 225   INLINE(void ProcessMarkingDeque(intptr_t bytes_to_process));
 226
 227   INLINE(void VisitObject(Map* map, HeapObject* obj, int size));
 228
 229   Heap* heap_;
 230
 231   State state_;
 232   bool is_compacting_;
 233
 234   VirtualMemory* marking_deque_memory_;
 235   bool marking_deque_memory_committed_;
 236   MarkingDeque marking_deque_;
 237
 238   int steps_count_;
 239   double steps_took_;
 240   double longest_step_;
 241   int64_t old_generation_space_available_at_start_of_incremental_;
 242   int64_t old_generation_space_used_at_start_of_incremental_;
 243   int steps_count_since_last_gc_;
 244   double steps_took_since_last_gc_;
 245   int64_t bytes_rescanned_;
 246   bool should_hurry_;
 247   int marking_speed_;
 248   intptr_t bytes_scanned_;
 249   intptr_t allocated_;
 250   intptr_t write_barriers_invoked_since_last_step_;
 251
 252   int no_marking_scope_depth_;
 253
 254   int unscanned_bytes_of_large_object_;
 255
 256   DISALLOW_IMPLICIT_CONSTRUCTORS(IncrementalMarking);
 257 };
 258
 259 } }  // namespace v8::internal
 260
 261 #endif  // V8_INCREMENTAL_MARKING_H_