Separate markbits from heap object map words into bitmaps.

src/mark-compact.cc

 // Copyright 2006-2008 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 28 matching lines @@
 namespace v8 {
 namespace internal {
 
 // -------------------------------------------------------------------------
 // MarkCompactCollector
 
 bool MarkCompactCollector::force_compaction_ = false;
 bool MarkCompactCollector::compacting_collection_ = false;
 bool MarkCompactCollector::compact_on_next_gc_ = false;
 
-int MarkCompactCollector::previous_marked_count_ = 0;
 GCTracer* MarkCompactCollector::tracer_ = NULL;
 
-
 #ifdef DEBUG
 MarkCompactCollector::CollectorState MarkCompactCollector::state_ = IDLE;
 
 // Counters used for debugging the marking phase of mark-compact or mark-sweep
 // collection.
 int MarkCompactCollector::live_bytes_ = 0;
 int MarkCompactCollector::live_young_objects_size_ = 0;
 int MarkCompactCollector::live_old_data_objects_size_ = 0;
 int MarkCompactCollector::live_old_pointer_objects_size_ = 0;
 int MarkCompactCollector::live_code_objects_size_ = 0;
 int MarkCompactCollector::live_map_objects_size_ = 0;
 int MarkCompactCollector::live_cell_objects_size_ = 0;
 int MarkCompactCollector::live_lo_objects_size_ = 0;
 #endif
 
 
+Marking::NewSpaceMarkbitsBitmap* Marking::new_space_bitmap_ = NULL;
+
+
+bool Marking::Setup() {
+  if (new_space_bitmap_ == NULL) {
+    int markbits_per_newspace =
+        (2*Heap::MaxSemiSpaceSize()) >> kPointerSizeLog2;
+
+    new_space_bitmap_ =
+        BitmapStorageDescriptor::Allocate(
+            NewSpaceMarkbitsBitmap::CellsForLength(markbits_per_newspace));
+  }
+  return new_space_bitmap_ != NULL;
+}
+
+
+void Marking::TearDown() {
+  if (new_space_bitmap_ != NULL) {
+    BitmapStorageDescriptor::Free(new_space_bitmap_);
+    new_space_bitmap_ = NULL;
+  }
+}
+
+
 void MarkCompactCollector::CollectGarbage() {
   // Make sure that Prepare() has been called. The individual steps below will
   // update the state as they proceed.
   ASSERT(state_ == PREPARE_GC);
 
   // Prepare has selected whether to compact the old generation or not.
   // Tell the tracer.
   if (IsCompacting()) tracer_->set_is_compacting();
 
   MarkLiveObjects();
 
   if (FLAG_collect_maps) ClearNonLiveTransitions();
 
   SweepLargeObjectSpace();
 
   SweepSpaces();
   PcToCodeCache::FlushPcToCodeCache();
 
   Finish();
 
-  // Save the count of marked objects remaining after the collection and
+  // Check that swept all marked objects and

[Erik Corry, 2011/01/07 12:13:21]

that swept -> that we swept
Also formatting is off.

   // null out the GC tracer.
-  previous_marked_count_ = tracer_->marked_count();
-  ASSERT(previous_marked_count_ == 0);
+  ASSERT(tracer_->marked_count() == 0);
   tracer_ = NULL;
 }
 
 
+#ifdef DEBUG
+static void VerifyMarkbitsAreClean(PagedSpace* space) {
+  PageIterator it(space, PageIterator::PAGES_IN_USE);
+
+  while (it.has_next()) {
+    Page* p = it.next();
+    ASSERT(p->markbits()->IsClean());
+  }
+}
+
+static void VerifyMarkbitsAreClean() {
+  VerifyMarkbitsAreClean(Heap::old_pointer_space());
+  VerifyMarkbitsAreClean(Heap::old_data_space());
+  VerifyMarkbitsAreClean(Heap::code_space());
+  VerifyMarkbitsAreClean(Heap::cell_space());
+  VerifyMarkbitsAreClean(Heap::map_space());
+}
+#endif
+
+
 void MarkCompactCollector::Prepare(GCTracer* tracer) {
   FLAG_flush_code = false;
   FLAG_always_compact = false;
   FLAG_never_compact = true;
 
   // Rather than passing the tracer around we stash it in a static member
   // variable.
   tracer_ = tracer;
 
 #ifdef DEBUG
@@ skipping 10 matching lines @@
   if (!Heap::map_space()->MapPointersEncodable())
       compacting_collection_ = false;
   if (FLAG_collect_maps) CreateBackPointers();
 
   PagedSpaces spaces;
   for (PagedSpace* space = spaces.next();
        space != NULL; space = spaces.next()) {
     space->PrepareForMarkCompact(compacting_collection_);
   }
 
+  Address new_space_top = Heap::new_space()->top();
+  Address new_space_bottom = Heap::new_space()->bottom();
+  Marking::ClearRange(new_space_bottom,
+                      static_cast<int>(new_space_top - new_space_bottom));
+
 #ifdef DEBUG
+  VerifyMarkbitsAreClean();
+
   live_bytes_ = 0;
   live_young_objects_size_ = 0;
   live_old_pointer_objects_size_ = 0;
   live_old_data_objects_size_ = 0;
   live_code_objects_size_ = 0;
   live_map_objects_size_ = 0;
   live_cell_objects_size_ = 0;
   live_lo_objects_size_ = 0;
 #endif
 }
@@ skipping 96 matching lines @@
     Code* lazy_compile = Builtins::builtin(Builtins::LazyCompile);
 
     JSFunction* candidate = jsfunction_candidates_head_;
     JSFunction* next_candidate;
     while (candidate != NULL) {
       next_candidate = GetNextCandidate(candidate);
 
       SharedFunctionInfo* shared = candidate->unchecked_shared();
 
       Code* code = shared->unchecked_code();
-      if (!code->IsMarked()) {
+      if (!Marking::IsMarked(code->address())) {
         shared->set_code(lazy_compile);
         candidate->set_code(lazy_compile);
       } else {
         candidate->set_code(shared->unchecked_code());
       }
 
       candidate = next_candidate;
     }
 
     jsfunction_candidates_head_ = NULL;
   }
 
 
   static void ProcessSharedFunctionInfoCandidates() {
     Code* lazy_compile = Builtins::builtin(Builtins::LazyCompile);
 
     SharedFunctionInfo* candidate = shared_function_info_candidates_head_;
     SharedFunctionInfo* next_candidate;
     while (candidate != NULL) {
       next_candidate = GetNextCandidate(candidate);
       SetNextCandidate(candidate, NULL);
 
       Code* code = candidate->unchecked_code();
-      if (!code->IsMarked()) {
+      if (!Marking::IsMarked(code->address())) {
         candidate->set_code(lazy_compile);
       }
 
       candidate = next_candidate;
     }
 
     shared_function_info_candidates_head_ = NULL;
   }
 
 
@@ skipping 51 matching lines @@
   //
   // Here we assume that if we change *p, we replace it with a heap object
   // (ie, the left substring of a cons string is always a heap object).
   //
   // The check performed is:
   //   object->IsConsString() && !object->IsSymbol() &&
   //   (ConsString::cast(object)->second() == Heap::empty_string())
   // except the maps for the object and its possible substrings might be
   // marked.
   HeapObject* object = HeapObject::cast(*p);
-  MapWord map_word = object->map_word();
-  map_word.ClearMark();
-  InstanceType type = map_word.ToMap()->instance_type();
+  InstanceType type = object->map()->instance_type();
   if ((type & kShortcutTypeMask) != kShortcutTypeTag) return object;
 
   Object* second = reinterpret_cast<ConsString*>(object)->unchecked_second();
   if (second != Heap::raw_unchecked_empty_string()) {
     return object;
   }
 
   // Since we don't have the object's start, it is impossible to update the
   // page dirty marks. Therefore, we only replace the string with its left
   // substring when page dirty marks do not change.
@@ skipping 134 matching lines @@
   INLINE(static void MarkObjectByPointer(Object** p)) {
     if (!(*p)->IsHeapObject()) return;
     HeapObject* object = ShortCircuitConsString(p);
     MarkCompactCollector::MarkObject(object);
   }
 
   // Visit an unmarked object.
   static inline void VisitUnmarkedObject(HeapObject* obj) {
 #ifdef DEBUG
     ASSERT(Heap::Contains(obj));
-    ASSERT(!obj->IsMarked());
+    ASSERT(!Marking::IsMarked(obj->address()));

[Erik Corry, 2011/01/07 12:13:21]

I wonder whether the compiler can work out that the -1 that the ->address()
performs can be omitted because the IsMarked shifts away the low bits.

 #endif
     Map* map = obj->map();
     MarkCompactCollector::SetMark(obj);
     // Mark the map pointer and the body.
     MarkCompactCollector::MarkObject(map);
     IterateBody(map, obj);
   }
 
   // Visit all unmarked objects pointed to by [start, end).
   // Returns false if the operation fails (lack of stack space).
   static inline bool VisitUnmarkedObjects(Object** start, Object** end) {

[Erik Corry, 2011/01/07 12:13:21]

It would be nice to disassemble this function to see whether the heroic inlining
we are expecting of the C++ compiler is actually taking place

     // Return false is we are close to the stack limit.
     StackLimitCheck check;
     if (check.HasOverflowed()) return false;
 
     // Visit the unmarked objects.
     for (Object** p = start; p < end; p++) {
       if (!(*p)->IsHeapObject()) continue;
       HeapObject* obj = HeapObject::cast(*p);
-      if (obj->IsMarked()) continue;
+      if (Marking::IsMarked(obj)) continue;
       VisitUnmarkedObject(obj);
     }
     return true;
   }
 
   static inline void VisitExternalReference(Address* p) { }
   static inline void VisitRuntimeEntry(RelocInfo* rinfo) { }
 
  private:
   class DataObjectVisitor {
@@ skipping 40 matching lines @@
   inline static bool IsCompiled(SharedFunctionInfo* function) {
     return
         function->unchecked_code() != Builtins::builtin(Builtins::LazyCompile);
   }
 
   inline static bool IsFlushable(JSFunction* function) {
     SharedFunctionInfo* shared_info = function->unchecked_shared();
 
     // Code is either on stack, in compilation cache or referenced
     // by optimized version of function.
-    if (function->unchecked_code()->IsMarked()) {
+    if (Marking::IsMarked(function->unchecked_code())) {
       shared_info->set_code_age(0);
       return false;
     }
 
     // We do not flush code for optimized functions.
     if (function->code() != shared_info->unchecked_code()) {
       return false;
     }
 
     return IsFlushable(shared_info);
   }
 
   inline static bool IsFlushable(SharedFunctionInfo* shared_info) {
     // Code is either on stack, in compilation cache or referenced
     // by optimized version of function.
-    if (shared_info->unchecked_code()->IsMarked()) {
+    if (Marking::IsMarked(shared_info->unchecked_code())) {
       shared_info->set_code_age(0);
       return false;
     }
 
     // The function must be compiled and have the source code available,
     // to be able to recompile it in case we need the function again.
     if (!(shared_info->is_compiled() && HasSourceCode(shared_info))) {
       return false;
     }
 
@@ skipping 30 matching lines @@
     // This function's code looks flushable. But we have to postpone the
     // decision until we see all functions that point to the same
     // SharedFunctionInfo because some of them might be optimized.
     // That would make the nonoptimized version of the code nonflushable,
     // because it is required for bailing out from optimized code.
     FlushCode::AddCandidate(function);
     return true;
   }
 
 
   static inline Map* SafeMap(Object* obj) {

[Erik Corry, 2011/01/07 12:13:21]

Get rid of this function?

-    MapWord map_word = HeapObject::cast(obj)->map_word();
-    map_word.ClearMark();
-    map_word.ClearOverflow();
-    return map_word.ToMap();
+    return HeapObject::cast(obj)->map();
   }
 
 
   static inline bool IsJSBuiltinsObject(Object* obj) {
     return obj->IsHeapObject() &&
         (SafeMap(obj)->instance_type() == JS_BUILTINS_OBJECT_TYPE);
   }
 
 
   static inline bool IsValidNotBuiltinContext(Object* ctx) {
@@ skipping 115 matching lines @@
                   SLOT_ADDR(object, JSFunction::kCodeEntryOffset));
 
     if (!flush_code_candidate) {
       VisitCodeEntry(object->address() + JSFunction::kCodeEntryOffset);
     } else {
       // Don't visit code object.
 
       // Visit shared function info to avoid double checking of it's
       // flushability.
       SharedFunctionInfo* shared_info = object->unchecked_shared();
-      if (!shared_info->IsMarked()) {
+      if (!Marking::IsMarked(shared_info)) {
         Map* shared_info_map = shared_info->map();
         MarkCompactCollector::SetMark(shared_info);
         MarkCompactCollector::MarkObject(shared_info_map);
         VisitSharedFunctionInfoAndFlushCodeGeneric(shared_info_map,
                                                    shared_info,
                                                    true);
       }
     }
 
     VisitPointers(SLOT_ADDR(object,
@@ skipping 125 matching lines @@
   void VisitPointers(Object** start, Object** end) {
     for (Object** p = start; p < end; p++) MarkObjectByPointer(p);
   }
 
  private:
   void MarkObjectByPointer(Object** p) {
     if (!(*p)->IsHeapObject()) return;
 
     // Replace flat cons strings in place.
     HeapObject* object = ShortCircuitConsString(p);
-    if (object->IsMarked()) return;
+    if (Marking::IsMarked(object)) return;
 
     Map* map = object->map();
     // Mark the object.
     MarkCompactCollector::SetMark(object);
 
     // Mark the map pointer and body, and push them on the marking stack.
     MarkCompactCollector::MarkObject(map);
     StaticMarkingVisitor::IterateBody(map, object);
 
     // Mark all the objects reachable from the map and body.  May leave
     // overflowed objects in the heap.
     MarkCompactCollector::EmptyMarkingStack();
   }
 };
 
 
 // Helper class for pruning the symbol table.
 class SymbolTableCleaner : public ObjectVisitor {
  public:
   SymbolTableCleaner() : pointers_removed_(0) { }
 
   virtual void VisitPointers(Object** start, Object** end) {
     // Visit all HeapObject pointers in [start, end).
     for (Object** p = start; p < end; p++) {
-      if ((*p)->IsHeapObject() && !HeapObject::cast(*p)->IsMarked()) {
+      if ((*p)->IsHeapObject() &&
+          !Marking::IsMarked(HeapObject::cast(*p))) {
         // Check if the symbol being pruned is an external symbol. We need to
         // delete the associated external data as this symbol is going away.
 
         // Since no objects have yet been moved we can safely access the map of
         // the object.
         if ((*p)->IsExternalString()) {
           Heap::FinalizeExternalString(String::cast(*p));
         }
         // Set the entry to null_value (as deleted).
         *p = Heap::raw_unchecked_null_value();
         pointers_removed_++;
       }
     }
   }
 
   int PointersRemoved() {
     return pointers_removed_;
   }
  private:
   int pointers_removed_;
 };
 
 
 // Implementation of WeakObjectRetainer for mark compact GCs. All marked objects
 // are retained.
 class MarkCompactWeakObjectRetainer : public WeakObjectRetainer {
  public:
   virtual Object* RetainAs(Object* object) {
-    MapWord first_word = HeapObject::cast(object)->map_word();
-    if (first_word.IsMarked()) {
+    if (Marking::IsMarked(HeapObject::cast(object))) {
       return object;
     } else {
       return NULL;
     }
   }
 };
 
 
-void MarkCompactCollector::MarkUnmarkedObject(HeapObject* object) {
-  ASSERT(!object->IsMarked());
+void MarkCompactCollector::ProcessNewlyMarkedObject(HeapObject* object) {
+  ASSERT(Marking::IsMarked(object));
   ASSERT(Heap::Contains(object));
   if (object->IsMap()) {
     Map* map = Map::cast(object);
     if (FLAG_cleanup_caches_in_maps_at_gc) {
       map->ClearCodeCache();
     }
-    SetMark(map);
     if (FLAG_collect_maps &&
         map->instance_type() >= FIRST_JS_OBJECT_TYPE &&
         map->instance_type() <= JS_FUNCTION_TYPE) {
       MarkMapContents(map);
     } else {
       marking_stack.Push(map);
     }
   } else {
-    SetMark(object);
     marking_stack.Push(object);
   }
 }
 
 
 void MarkCompactCollector::MarkMapContents(Map* map) {
   MarkDescriptorArray(reinterpret_cast<DescriptorArray*>(
       *HeapObject::RawField(map, Map::kInstanceDescriptorsOffset)));
 
   // Mark the Object* fields of the Map.
   // Since the descriptor array has been marked already, it is fine
   // that one of these fields contains a pointer to it.
   Object** start_slot = HeapObject::RawField(map,
                                              Map::kPointerFieldsBeginOffset);
 
   Object** end_slot = HeapObject::RawField(map, Map::kPointerFieldsEndOffset);
 
   StaticMarkingVisitor::VisitPointers(start_slot, end_slot);
 }
 
 
 void MarkCompactCollector::MarkDescriptorArray(
     DescriptorArray* descriptors) {
-  if (descriptors->IsMarked()) return;
+  if (Marking::IsMarked(descriptors)) return;
   // Empty descriptor array is marked as a root before any maps are marked.
   ASSERT(descriptors != Heap::raw_unchecked_empty_descriptor_array());
   SetMark(descriptors);
 
   FixedArray* contents = reinterpret_cast<FixedArray*>(
       descriptors->get(DescriptorArray::kContentArrayIndex));
   ASSERT(contents->IsHeapObject());
-  ASSERT(!contents->IsMarked());
+  ASSERT(!Marking::IsMarked(contents));
   ASSERT(contents->IsFixedArray());
   ASSERT(contents->length() >= 2);
   SetMark(contents);
   // Contents contains (value, details) pairs.  If the details say that
   // the type of descriptor is MAP_TRANSITION, CONSTANT_TRANSITION, or
   // NULL_DESCRIPTOR, we don't mark the value as live.  Only for
   // MAP_TRANSITION and CONSTANT_TRANSITION is the value an Object* (a
   // Map*).
   for (int i = 0; i < contents->length(); i += 2) {
     // If the pair (value, details) at index i, i+1 is not
     // a transition or null descriptor, mark the value.
     PropertyDetails details(Smi::cast(contents->get(i + 1)));
     if (details.type() < FIRST_PHANTOM_PROPERTY_TYPE) {
       HeapObject* object = reinterpret_cast<HeapObject*>(contents->get(i));
-      if (object->IsHeapObject() && !object->IsMarked()) {
+      if (object->IsHeapObject() && !Marking::IsMarked(object)) {
         SetMark(object);
         marking_stack.Push(object);
       }
     }
   }
   // The DescriptorArray descriptors contains a pointer to its contents array,
   // but the contents array is already marked.
   marking_stack.Push(descriptors);
 }
 
@@ skipping 11 matching lines @@
         ASSERT(map->instance_descriptors() == Heap::empty_descriptor_array());
       }
     }
   }
 }
 
 
 static int OverflowObjectSize(HeapObject* obj) {
   // Recover the normal map pointer, it might be marked as live and
   // overflowed.
-  MapWord map_word = obj->map_word();
-  map_word.ClearMark();
-  map_word.ClearOverflow();
-  return obj->SizeFromMap(map_word.ToMap());
+  return obj->Size();
 }
 
 
 // Fill the marking stack with overflowed objects returned by the given
 // iterator.  Stop when the marking stack is filled or the end of the space
 // is reached, whichever comes first.
 template<class T>
 static void ScanOverflowedObjects(T* it) {
+#if 0
   // The caller should ensure that the marking stack is initially not full,
   // so that we don't waste effort pointlessly scanning for objects.
   ASSERT(!marking_stack.is_full());
 
   for (HeapObject* object = it->next(); object != NULL; object = it->next()) {
     if (object->IsOverflowed()) {
       object->ClearOverflow();
-      ASSERT(object->IsMarked());
+      ASSERT(Marking::IsMarked(object));
       ASSERT(Heap::Contains(object));
       marking_stack.Push(object);
       if (marking_stack.is_full()) return;
     }
   }
+#endif
+  UNREACHABLE();
 }
 
 
 bool MarkCompactCollector::IsUnmarkedHeapObject(Object** p) {
-  return (*p)->IsHeapObject() && !HeapObject::cast(*p)->IsMarked();
+  return (*p)->IsHeapObject() &&
+      !Marking::IsMarked(HeapObject::cast(*p));
 }
 
 
 void MarkCompactCollector::MarkSymbolTable() {
   SymbolTable* symbol_table = Heap::raw_unchecked_symbol_table();
   // Mark the symbol table itself.
   SetMark(symbol_table);
   // Explicitly mark the prefix.
   MarkingVisitor marker;
   symbol_table->IteratePrefix(&marker);
@@ skipping 21 matching lines @@
   List<ObjectGroup*>* object_groups = GlobalHandles::ObjectGroups();
 
   for (int i = 0; i < object_groups->length(); i++) {
     ObjectGroup* entry = object_groups->at(i);
     if (entry == NULL) continue;
 
     List<Object**>& objects = entry->objects_;
     bool group_marked = false;
     for (int j = 0; j < objects.length(); j++) {
       Object* object = *objects[j];
-      if (object->IsHeapObject() && HeapObject::cast(object)->IsMarked()) {
+      if (object->IsHeapObject() && Marking::IsMarked(HeapObject::cast(object))) {
         group_marked = true;
         break;
       }
     }
 
     if (!group_marked) continue;
 
     // An object in the group is marked, so mark as gray all white heap
     // objects in the group.
     for (int j = 0; j < objects.length(); ++j) {
@@ skipping 11 matching lines @@
 
 // Mark all objects reachable from the objects on the marking stack.
 // Before: the marking stack contains zero or more heap object pointers.
 // After: the marking stack is empty, and all objects reachable from the
 // marking stack have been marked, or are overflowed in the heap.
 void MarkCompactCollector::EmptyMarkingStack() {
   while (!marking_stack.is_empty()) {
     HeapObject* object = marking_stack.Pop();
     ASSERT(object->IsHeapObject());
     ASSERT(Heap::Contains(object));
-    ASSERT(object->IsMarked());
+    ASSERT(Marking::IsMarked(object));
     ASSERT(!object->IsOverflowed());
 
     // Because the object is marked, we have to recover the original map

[Erik Corry, 2011/01/07 12:13:21]

comment out of date

     // pointer and use it to mark the object's body.
-    MapWord map_word = object->map_word();
-    map_word.ClearMark();
-    Map* map = map_word.ToMap();
+    Map* map = object->map();
     MarkObject(map);
 
     StaticMarkingVisitor::IterateBody(map, object);
   }
 }
 
 
 // Sweep the heap for overflowed objects, clear their overflow bits, and
 // push them on the marking stack.  Stop early if the marking stack fills
 // before sweeping completes.  If sweeping completes, there are no remaining
@@ skipping 159 matching lines @@
   ASSERT(state_ == MARK_LIVE_OBJECTS);
   state_ =
       compacting_collection_ ? ENCODE_FORWARDING_ADDRESSES : SWEEP_SPACES;
 #endif
   // Deallocate unmarked objects and clear marked bits for marked objects.
   Heap::lo_space()->FreeUnmarkedObjects();
 }
 
 
 // Safe to use during marking phase only.
 bool MarkCompactCollector::SafeIsMap(HeapObject* object) {

[Erik Corry, 2011/01/07 12:13:21]

Remove or rename?

-  MapWord metamap = object->map_word();
-  metamap.ClearMark();
-  return metamap.ToMap()->instance_type() == MAP_TYPE;
+  return object->map()->instance_type() == MAP_TYPE;
 }
 
 
 void MarkCompactCollector::ClearNonLiveTransitions() {
   HeapObjectIterator map_iterator(Heap::map_space(), &SizeOfMarkedObject);
   // Iterate over the map space, setting map transitions that go from
   // a marked map to an unmarked map to null transitions.  At the same time,
   // set all the prototype fields of maps back to their original value,
   // dropping the back pointers temporarily stored in the prototype field.
   // Setting the prototype field requires following the linked list of
   // back pointers, reversing them all at once.  This allows us to find
   // those maps with map transitions that need to be nulled, and only
   // scan the descriptor arrays of those maps, not all maps.
   // All of these actions are carried out only on maps of JSObjects
   // and related subtypes.
   for (HeapObject* obj = map_iterator.next();
        obj != NULL; obj = map_iterator.next()) {
     Map* map = reinterpret_cast<Map*>(obj);
-    if (!map->IsMarked() && map->IsByteArray()) continue;
+    if (!Marking::IsMarked(map) && map->IsByteArray()) continue;
 
     ASSERT(SafeIsMap(map));
     // Only JSObject and subtypes have map transitions and back pointers.
     if (map->instance_type() < FIRST_JS_OBJECT_TYPE) continue;
     if (map->instance_type() > JS_FUNCTION_TYPE) continue;
 
-    if (map->IsMarked() && map->attached_to_shared_function_info()) {
+    if (Marking::IsMarked(map) &&
+        map->attached_to_shared_function_info()) {
       // This map is used for inobject slack tracking and has been detached
       // from SharedFunctionInfo during the mark phase.
       // Since it survived the GC, reattach it now.
       map->unchecked_constructor()->unchecked_shared()->AttachInitialMap(map);
     }
 
     // Follow the chain of back pointers to find the prototype.
     Map* current = map;
     while (SafeIsMap(current)) {
       current = reinterpret_cast<Map*>(current->prototype());
       ASSERT(current->IsHeapObject());
     }
     Object* real_prototype = current;
 
     // Follow back pointers, setting them to prototype,
     // clearing map transitions when necessary.
     current = map;
-    bool on_dead_path = !current->IsMarked();
+    bool on_dead_path = !Marking::IsMarked(current);
     Object* next;
     while (SafeIsMap(current)) {
       next = current->prototype();
       // There should never be a dead map above a live map.
-      ASSERT(on_dead_path || current->IsMarked());
+      ASSERT(on_dead_path || Marking::IsMarked(current));
 
       // A live map above a dead map indicates a dead transition.
       // This test will always be false on the first iteration.
-      if (on_dead_path && current->IsMarked()) {
+      if (on_dead_path && Marking::IsMarked(current)) {
         on_dead_path = false;
         current->ClearNonLiveTransitions(real_prototype);
       }
       *HeapObject::RawField(current, Map::kPrototypeOffset) =
           real_prototype;
       current = reinterpret_cast<Map*>(next);
     }
   }
 }
 
@@ skipping 128 matching lines @@
       MarkCompactCollector::tracer()->
           increment_promoted_objects_size(object_size);
       return true;
     }
   }
 
   return false;
 }
 
 
-static void SweepNewSpace(NewSpace* space) {
+void MarkCompactCollector::SweepNewSpace(NewSpace* space) {
   Heap::CheckNewSpaceExpansionCriteria();
 
   Address from_bottom = space->bottom();
   Address from_top = space->top();
 
   // Flip the semispaces.  After flipping, to space is empty, from space has
   // live objects.
   space->Flip();
   space->ResetAllocationInfo();
 
   int size = 0;
   int survivors_size = 0;
 
   // First pass: traverse all objects in inactive semispace, remove marks,
   // migrate live objects and write forwarding addresses.
   for (Address current = from_bottom; current < from_top; current += size) {
     HeapObject* object = HeapObject::FromAddress(current);
 
-    if (object->IsMarked()) {
-      object->ClearMark();
+    if (Marking::IsMarked(object)) {
+      Marking::ClearMark(object);
       MarkCompactCollector::tracer()->decrement_marked_count();
 
       size = object->Size();
       survivors_size += size;
 
       // Aggressively promote young survivors to the old space.
       if (TryPromoteObject(object, size)) {
         continue;
       }
 
@@ skipping 53 matching lines @@
   // Update pointers from external string table.
   Heap::UpdateNewSpaceReferencesInExternalStringTable(
       &UpdateNewSpaceReferenceInExternalStringTableEntry);
 
   // All pointers were updated. Update auxiliary allocation info.
   Heap::IncrementYoungSurvivorsCounter(survivors_size);
   space->set_age_mark(space->top());
 }
 
 
-static void SweepSpace(PagedSpace* space) {
+void MarkCompactCollector::SweepSpace(PagedSpace* space) {
   PageIterator it(space, PageIterator::PAGES_IN_USE);
 
   // During sweeping of paged space we are trying to find longest sequences
   // of pages without live objects and free them (instead of putting them on
   // the free list).
 
   // Page preceding current.
   Page* prev = Page::FromAddress(NULL);
 
   // First empty page in a sequence.
@@ skipping 15 matching lines @@
     Page* p = it.next();
 
     bool is_previous_alive = true;
     Address free_start = NULL;
     HeapObject* object;
 
     for (Address current = p->ObjectAreaStart();
          current < p->AllocationTop();
          current += object->Size()) {
       object = HeapObject::FromAddress(current);
-      if (object->IsMarked()) {
-        object->ClearMark();
+      if (Marking::IsMarked(object)) {
+        Marking::ClearMark(object);
         MarkCompactCollector::tracer()->decrement_marked_count();
 
         if (!is_previous_alive) {  // Transition from free to live.
           space->DeallocateBlock(free_start,
                                  static_cast<int>(current - free_start),
                                  true);
           is_previous_alive = true;
         }
       } else {
         MarkCompactCollector::ReportDeleteIfNeeded(object);
@@ skipping 171 matching lines @@
 #ifdef ENABLE_LOGGING_AND_PROFILING
   if (obj->IsCode()) {
     PROFILE(CodeDeleteEvent(obj->address()));
   } else if (obj->IsJSFunction()) {
     PROFILE(FunctionDeleteEvent(obj->address()));
   }
 #endif
 }
 
 
 int MarkCompactCollector::SizeOfMarkedObject(HeapObject* obj) {

[Erik Corry, 2011/01/07 12:13:21]

This function is not needed

-  MapWord map_word = obj->map_word();
-  map_word.ClearMark();
-  return obj->SizeFromMap(map_word.ToMap());
+  return obj->Size();
 }
 
 
 void MarkCompactCollector::Initialize() {
   StaticPointersToNewGenUpdatingVisitor::Initialize();
   StaticMarkingVisitor::Initialize();
 }
 
 
 } }  // namespace v8::internal