[heap] More flag cleanup.

src/heap/heap.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_HEAP_HEAP_H_
 #define V8_HEAP_HEAP_H_
 
 #include <cmath>
 #include <map>
 
 #include "src/allocation.h"
 #include "src/assert-scope.h"
+#include "src/base/flags.h"
 #include "src/globals.h"
 #include "src/heap/gc-idle-time-handler.h"
 #include "src/heap/incremental-marking.h"
 #include "src/heap/mark-compact.h"
 #include "src/heap/objects-visiting.h"
 #include "src/heap/spaces.h"
 #include "src/heap/store-buffer.h"
 #include "src/list.h"
 
 namespace v8 {
@@ skipping 591 matching lines @@
                         kStringTableRootIndex,
 
 #define ROOT_INDEX_DECLARATION(type, name, camel_name) k##camel_name##RootIndex,
     SMI_ROOT_LIST(ROOT_INDEX_DECLARATION)
 #undef ROOT_INDEX_DECLARATION
         kRootListLength,
     kStrongRootListLength = kStringTableRootIndex,
     kSmiRootsStart = kStringTableRootIndex + 1
   };
 
+  // Flags to indicate modes for a GC run.
+  enum GCFlag {
+    kNoGCFlags = 0u,
+    kReduceMemoryFootprintMask = 1u << 0,
+    kAbortIncrementalMarkingMask = 1u << 1,
+    kFinalizeIncrementalMarkingMask = 1u << 2,
+
+    // Making the heap iterable requires us to abort incremental marking.
+    kMakeHeapIterableMask = kAbortIncrementalMarkingMask,
+  };
+  typedef base::Flags<GCFlag> GCFlags;
+
+  enum GCFlagOverride {
+    kOverride,
+    kDontOverride,
+  };
+
   // Indicates whether live bytes adjustment is triggered
   // - from within the GC code before sweeping started (SEQUENTIAL_TO_SWEEPER),
   // - or from within GC (CONCURRENT_TO_SWEEPER),
   // - or mutator code (CONCURRENT_TO_SWEEPER).
   enum InvocationMode { SEQUENTIAL_TO_SWEEPER, CONCURRENT_TO_SWEEPER };
 
   enum ScratchpadSlotMode { IGNORE_SCRATCHPAD_SLOT, RECORD_SCRATCHPAD_SLOT };
 
   enum HeapState { NOT_IN_GC, SCAVENGE, MARK_COMPACT };
 
   // ObjectStats are kept in two arrays, counts and sizes. Related stats are
   // stored in a contiguous linear buffer. Stats groups are stored one after
   // another.
   enum {
     FIRST_CODE_KIND_SUB_TYPE = LAST_TYPE + 1,
     FIRST_FIXED_ARRAY_SUB_TYPE =
         FIRST_CODE_KIND_SUB_TYPE + Code::NUMBER_OF_KINDS,
     FIRST_CODE_AGE_SUB_TYPE =
         FIRST_FIXED_ARRAY_SUB_TYPE + LAST_FIXED_ARRAY_SUB_TYPE + 1,
     OBJECT_STATS_COUNT = FIRST_CODE_AGE_SUB_TYPE + Code::kCodeAgeCount + 1
   };
 
+  class GCFlagScope {
+   public:
+    GCFlagScope(Heap* heap, GCFlags gc_flags, GCCallbackFlags callback_flags,
+                GCFlagOverride override)
+        : heap_(heap), override_(override) {
+      if (override_ == kDontOverride) {
+        saved_gc_flags_ = heap->current_gc_flags_;
+        saved_gc_callback_flags_ = heap->current_gc_callback_flags_;
+      }
+      heap->set_current_gc_flags(gc_flags);
+      heap->current_gc_callback_flags_ = callback_flags;
+    }
+
+    ~GCFlagScope() {
+      if (override_ == kDontOverride) {
+        heap_->set_current_gc_flags(saved_gc_flags_);
+        heap_->current_gc_callback_flags_ = saved_gc_callback_flags_;
+      } else {
+        heap_->set_current_gc_flags(kNoGCFlags);
+        heap_->current_gc_callback_flags_ = kNoGCCallbackFlags;
+      }
+    }
+
+   private:
+    Heap* heap_;
+    GCFlagOverride override_;
+    GCFlags saved_gc_flags_;
+    GCCallbackFlags saved_gc_callback_flags_;
+  };
+
   // Taking this lock prevents the GC from entering a phase that relocates
   // object references.
   class RelocationLock {
    public:
     explicit RelocationLock(Heap* heap) : heap_(heap) {
       heap_->relocation_mutex_.Lock();
     }
 
     ~RelocationLock() { heap_->relocation_mutex_.Unlock(); }
 
@@ skipping 82 matching lines @@
   // Strict mode arguments has no callee so it is smaller.
   static const int kStrictArgumentsObjectSize =
       JSObject::kHeaderSize + 1 * kPointerSize;
 
   // Indicies for direct access into argument objects.
   static const int kArgumentsLengthIndex = 0;
 
   // callee is only valid in sloppy mode.
   static const int kArgumentsCalleeIndex = 1;
 
-  static const int kNoGCFlags = 0;
-  static const int kReduceMemoryFootprintMask = 1;
-  static const int kAbortIncrementalMarkingMask = 2;
-  static const int kFinalizeIncrementalMarkingMask = 4;
-
-  // Making the heap iterable requires us to abort incremental marking.
-  static const int kMakeHeapIterableMask = kAbortIncrementalMarkingMask;
-
   // The roots that have an index less than this are always in old space.
   static const int kOldSpaceRoots = 0x20;
 
   STATIC_ASSERT(kUndefinedValueRootIndex ==
                 Internals::kUndefinedValueRootIndex);
   STATIC_ASSERT(kNullValueRootIndex == Internals::kNullValueRootIndex);
   STATIC_ASSERT(kTrueValueRootIndex == Internals::kTrueValueRootIndex);
   STATIC_ASSERT(kFalseValueRootIndex == Internals::kFalseValueRootIndex);
   STATIC_ASSERT(kempty_stringRootIndex == Internals::kEmptyStringRootIndex);
 
@@ skipping 539 matching lines @@
   bool inline_allocation_disabled() { return inline_allocation_disabled_; }
 
   // Switch whether inline bump-pointer allocation should be used.
   void EnableInlineAllocation();
   void DisableInlineAllocation();
 
   // ===========================================================================
   // Methods triggering GCs. ===================================================
   // ===========================================================================
 
-  // Performs garbage collection operation.
+  // Perform a garbage collection operation in a given space.
   // Returns whether there is a chance that another major GC could
   // collect more garbage.

[Hannes Payer (out of office), 2015/08/27 12:41:14]

Explain in detail here how the flags work.

   inline bool CollectGarbage(
-      AllocationSpace space, const char* gc_reason = NULL,
-      const GCCallbackFlags gc_callback_flags = kNoGCCallbackFlags);
+      AllocationSpace space, const char* gc_reason = nullptr,
+      const GCFlags flags = kNoGCFlags,
+      const GCCallbackFlags callback_flags = kNoGCCallbackFlags,
+      const GCFlagOverride override = kOverride);
 
-  // Performs a full garbage collection.  If (flags & kMakeHeapIterableMask) is
-  // non-zero, then the slower precise sweeper is used, which leaves the heap
-  // in a state where we can iterate over the heap visiting all objects.
+  inline bool CollectGarbageNewSpace(const char* gc_reason = nullptr);

[Hannes Payer (out of office), 2015/08/27 12:41:14]

Also mention here what impact the flags have.

+
+  // Performs a full garbage collection.
   void CollectAllGarbage(
-      int flags = kFinalizeIncrementalMarkingMask, const char* gc_reason = NULL,
+      const char* gc_reason = nullptr,
+      const GCFlags flags = Heap::kFinalizeIncrementalMarkingMask,
       const GCCallbackFlags gc_callback_flags = kNoGCCallbackFlags);
 
   // Last hope GC, should try to squeeze as much as possible.
-  void CollectAllAvailableGarbage(const char* gc_reason = NULL);
+  void CollectAllAvailableGarbage(const char* gc_reason = nullptr);
 
   // Invoked when GC was requested via the stack guard.
   void HandleGCRequest();
 
   // ===========================================================================
   // Iterators. ================================================================
   // ===========================================================================
 
   // Iterates over all roots in the heap.
   void IterateRoots(ObjectVisitor* v, VisitMode mode);
@@ skipping 28 matching lines @@
   // ===========================================================================
   // Incremental marking API. ==================================================
   // ===========================================================================
 
   // Start incremental marking and ensure that idle time handler can perform
   // incremental steps.
   void StartIdleIncrementalMarking();
 
   // Starts incremental marking assuming incremental marking is currently
   // stopped.
-  void StartIncrementalMarking(int gc_flags = kNoGCFlags,
+  void StartIncrementalMarking(const GCFlags = kNoGCFlags,
                                const GCCallbackFlags gc_callback_flags =
                                    GCCallbackFlags::kNoGCCallbackFlags,
                                const char* reason = nullptr);
 
   // Performs incremental marking steps of step_size_in_bytes as long as
   // deadline_ins_ms is not reached. step_size_in_bytes can be 0 to compute
   // an estimate increment. Returns the remaining time that cannot be used
   // for incremental marking anymore because a single step would exceed the
   // deadline.
   double AdvanceIncrementalMarking(
@@ skipping 290 matching lines @@
     return (pretenure == TENURED) ? OLD_SPACE : NEW_SPACE;
   }
 
 #define ROOT_ACCESSOR(type, name, camel_name) \
   inline void set_##name(type* value);
   ROOT_LIST(ROOT_ACCESSOR)
 #undef ROOT_ACCESSOR
 
   StoreBuffer* store_buffer() { return &store_buffer_; }
 
-  void set_current_gc_flags(int flags) {
+  void set_current_gc_flags(GCFlags flags) {
     current_gc_flags_ = flags;
     DCHECK(!ShouldFinalizeIncrementalMarking() ||
            !ShouldAbortIncrementalMarking());
   }
 
   inline bool ShouldReduceMemory() const {
     return current_gc_flags_ & kReduceMemoryFootprintMask;
   }
 
   inline bool ShouldAbortIncrementalMarking() const {
@@ skipping 21 matching lines @@
   // with the allocation memento of the object at the top
   void EnsureFillerObjectAtTop();
 
   // Ensure that we have swept all spaces in such a way that we can iterate
   // over all objects.  May cause a GC.
   void MakeHeapIterable();
 
   // Performs garbage collection operation.
   // Returns whether there is a chance that another major GC could
   // collect more garbage.
-  bool CollectGarbage(
-      GarbageCollector collector, const char* gc_reason,
-      const char* collector_reason,
-      const GCCallbackFlags gc_callback_flags = kNoGCCallbackFlags);
+  bool CollectGarbage(GarbageCollector collector, const char* gc_reason,
+                      const char* collector_reason);
 
   // Performs garbage collection
   // Returns whether there is a chance another major GC could
   // collect more garbage.
-  bool PerformGarbageCollection(
-      GarbageCollector collector,
-      const GCCallbackFlags gc_callback_flags = kNoGCCallbackFlags);
+  bool PerformGarbageCollection(GarbageCollector collector);
 
   inline void UpdateOldSpaceLimits();
 
   // Initializes a JSObject based on its map.
   void InitializeJSObjectFromMap(JSObject* obj, FixedArray* properties,
                                  Map* map);
   void InitializeAllocationMemento(AllocationMemento* memento,
                                    AllocationSite* allocation_site);
 
   bool CreateInitialMaps();
@@ skipping 599 matching lines @@
   size_t ring_buffer_end_;
 
   // Shared state read by the scavenge collector and set by ScavengeObject.
   PromotionQueue promotion_queue_;
 
   // Flag is set when the heap has been configured.  The heap can be repeatedly
   // configured through the API until it is set up.
   bool configured_;
 
   // Currently set GC flags that are respected by all GC components.
-  int current_gc_flags_;
+  GCFlags current_gc_flags_;
 
   // Currently set GC callback flags that are used to pass information between
   // the embedder and V8's GC.
   GCCallbackFlags current_gc_callback_flags_;
 
   ExternalStringTable external_string_table_;
 
   VisitorDispatchTable<ScavengingCallback> scavenging_visitors_table_;
 
   MemoryChunk* chunks_queued_for_free_;
@@ skipping 410 matching lines @@
   DisallowHeapAllocation no_allocation;  // i.e. no gc allowed.
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(PathTracer);
 };
 #endif  // DEBUG
 }
 }  // namespace v8::internal
 
 #endif  // V8_HEAP_HEAP_H_