Provide baseline for experimental GC implementation.

src/heap.cc

 // Copyright 2010 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 207 matching lines @@
 int Heap::GcSafeSizeOfOldObject(HeapObject* object) {
   ASSERT(!Heap::InNewSpace(object));  // Code only works for old objects.
   ASSERT(!MarkCompactCollector::are_map_pointers_encoded());
   MapWord map_word = object->map_word();
   map_word.ClearMark();
   map_word.ClearOverflow();
   return object->SizeFromMap(map_word.ToMap());
 }
 
 
-int Heap::GcSafeSizeOfOldObjectWithEncodedMap(HeapObject* object) {
-  ASSERT(!Heap::InNewSpace(object));  // Code only works for old objects.
-  ASSERT(MarkCompactCollector::are_map_pointers_encoded());
-  uint32_t marker = Memory::uint32_at(object->address());
-  if (marker == MarkCompactCollector::kSingleFreeEncoding) {
-    return kIntSize;
-  } else if (marker == MarkCompactCollector::kMultiFreeEncoding) {
-    return Memory::int_at(object->address() + kIntSize);
-  } else {
-    MapWord map_word = object->map_word();
-    Address map_address = map_word.DecodeMapAddress(Heap::map_space());
-    Map* map = reinterpret_cast<Map*>(HeapObject::FromAddress(map_address));
-    return object->SizeFromMap(map);
-  }
-}
-
-
 GarbageCollector Heap::SelectGarbageCollector(AllocationSpace space) {
   // Is global GC requested?
   if (space != NEW_SPACE || FLAG_gc_global) {
     Counters::gc_compactor_caused_by_request.Increment();
     return MARK_COMPACTOR;
   }
 
   // Is enough data promoted to justify a global GC?
   if (OldGenerationPromotionLimitReached()) {
     Counters::gc_compactor_caused_by_promoted_data.Increment();
@@ skipping 3732 matching lines @@
 
 
 void Heap::Verify() {
   ASSERT(HasBeenSetup());
 
   VerifyPointersVisitor visitor;
   IterateRoots(&visitor, VISIT_ONLY_STRONG);
 
   new_space_.Verify();
 
-  VerifyPointersAndDirtyRegionsVisitor dirty_regions_visitor;
-  old_pointer_space_->Verify(&dirty_regions_visitor);
-  map_space_->Verify(&dirty_regions_visitor);
+  old_pointer_space_->Verify(&visitor);
+  map_space_->Verify(&visitor);
 
   VerifyPointersUnderWatermark(old_pointer_space_,
                                &IteratePointersInDirtyRegion);
   VerifyPointersUnderWatermark(map_space_,
                                &IteratePointersInDirtyMapsRegion);
   VerifyPointersUnderWatermark(lo_space_);
 
   VerifyPageWatermarkValidity(old_pointer_space_, ALL_INVALID);
   VerifyPageWatermarkValidity(map_space_, ALL_INVALID);
 
@@ skipping 200 matching lines @@
   page->SetRegionMarks(marks);
 }
 
 
 uint32_t Heap::IterateDirtyRegions(
     uint32_t marks,
     Address area_start,
     Address area_end,
     DirtyRegionCallback visit_dirty_region,
     ObjectSlotCallback copy_object_func) {
+#ifndef ENABLE_CARDMARKING_WRITE_BARRIER
+  ASSERT(marks == Page::kAllRegionsDirtyMarks);
+  visit_dirty_region(area_start, area_end, copy_object_func);
+  return Page::kAllRegionsDirtyMarks;
+#else
   uint32_t newmarks = 0;
   uint32_t mask = 1;
 
   if (area_start >= area_end) {
     return newmarks;
   }
 
   Address region_start = area_start;
 
   // area_start does not necessarily coincide with start of the first region.
@@ skipping 36 matching lines @@
     // with region end. Check whether region covering last part of area is
     // dirty.
     if (marks & mask) {
       if (visit_dirty_region(region_start, area_end, copy_object_func)) {
         newmarks |= mask;
       }
     }
   }
 
   return newmarks;
+#endif
 }
 
 
 
 void Heap::IterateDirtyRegions(
     PagedSpace* space,
     DirtyRegionCallback visit_dirty_region,
     ObjectSlotCallback copy_object_func,
     ExpectedPageWatermarkState expected_page_watermark_state) {
 
@@ skipping 1162 matching lines @@
 void ExternalStringTable::TearDown() {
   new_space_strings_.Free();
   old_space_strings_.Free();
 }
 
 
 List<Object*> ExternalStringTable::new_space_strings_;
 List<Object*> ExternalStringTable::old_space_strings_;
 
 } }  // namespace v8::internal