Create an abstraction (MarkBit) object to hold the location of the...

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 1110 matching lines @@
 
   // Check new space expansion criteria and expand semispaces if it was hit.
   static void CheckNewSpaceExpansionCriteria();
 
   static inline void IncrementYoungSurvivorsCounter(int survived) {
     young_survivors_after_last_gc_ = survived;
     survived_since_last_expansion_ += survived;
   }
 
   static inline bool NextGCIsLikelyToBeFull() {
+    if (FLAG_gc_global) return true;
+
     intptr_t total_promoted =
         PromotedSpaceSize() + PromotedExternalMemorySize();
 
     intptr_t adjusted_promotion_limit =
         old_gen_promotion_limit_ - new_space_.Capacity();
 
     if (total_promoted >= adjusted_promotion_limit) return true;
 
     intptr_t adjusted_allocation_limit =
         old_gen_allocation_limit_ - new_space_.Capacity() / 5;
@@ skipping 623 matching lines @@
   bool is_empty() { return top_ <= low_; }
 
   bool overflowed() { return overflowed_; }
 
   void clear_overflowed() { overflowed_ = false; }
 
   // Push the (marked) object on the marking stack if there is room,
   // otherwise mark the object as overflowed and wait for a rescan of the
   // heap.
   void Push(HeapObject* object) {
-    CHECK(object->IsHeapObject());
+    ASSERT(object->IsHeapObject());
     if (is_full()) {
       object->SetOverflow();
       overflowed_ = true;
     } else {
       *(top_++) = object;
     }
   }
 
   HeapObject* Pop() {
     ASSERT(!is_empty());
     HeapObject* object = *(--top_);
-    CHECK(object->IsHeapObject());
+    ASSERT(object->IsHeapObject());

[Vyacheslav Egorov (Chromium), 2011/03/21 16:54:23]

Do we really want this?

Sometimes it's better to have an early detection of mark stack corruption.

[Erik Corry, 2011/03/21 20:48:53]

This is inlined in some of our hottest GC functions.  I'm going to follow the
pattern in the entire rest of the VM and leave sanity tests to the debug
version.

     return object;
   }
 
  private:
   HeapObject** low_;
   HeapObject** top_;
   HeapObject** high_;
   bool overflowed_;
 };
 
@@ skipping 438 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_