Provide baseline for new GC infrastructure.

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 64 matching lines @@
   // Tell the tracer.
   if (IsCompacting()) tracer_->set_is_compacting();
 
   MarkLiveObjects();
 
   if (FLAG_collect_maps) ClearNonLiveTransitions();
 
   SweepLargeObjectSpace();
 
   if (IsCompacting()) {
+    ASSERT(!FLAG_new_gc);
+
     GCTracer::Scope gc_scope(tracer_, GCTracer::Scope::MC_COMPACT);
     EncodeForwardingAddresses();
 
     Heap::MarkMapPointersAsEncoded(true);
     UpdatePointers();
     Heap::MarkMapPointersAsEncoded(false);
     PcToCodeCache::FlushPcToCodeCache();
 
     RelocateObjects();
   } else {
     SweepSpaces();
     PcToCodeCache::FlushPcToCodeCache();
   }
 
   Finish();
 
   // Save the count of marked objects remaining after the collection and
   // null out the GC tracer.
   previous_marked_count_ = tracer_->marked_count();
   ASSERT(previous_marked_count_ == 0);
   tracer_ = NULL;
 }
 
 
 void MarkCompactCollector::Prepare(GCTracer* tracer) {
+  if (FLAG_new_gc) {
+    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
   ASSERT(state_ == IDLE);
   state_ = PREPARE_GC;
 #endif
   ASSERT(!FLAG_always_compact || !FLAG_never_compact);
 
@@ skipping 2220 matching lines @@
 
   Heap::IterateDirtyRegions(Heap::map_space(),
                             &Heap::IteratePointersInDirtyMapsRegion,
                             &UpdatePointerToNewGen,
                             Heap::WATERMARK_SHOULD_BE_VALID);
 
   intptr_t live_maps_size = Heap::map_space()->Size();
   int live_maps = static_cast<int>(live_maps_size / Map::kSize);
   ASSERT(live_map_objects_size_ == live_maps_size);
 
-  if (Heap::map_space()->NeedsCompaction(live_maps)) {
+  if (!FLAG_new_gc && Heap::map_space()->NeedsCompaction(live_maps)) {

[Erik Corry, 2010/12/13 19:58:28]

Shouldnt this be !FLAG_never_compact.  Looks a little like a bug in the old GC.

     MapCompact map_compact(live_maps);
 
     map_compact.CompactMaps();
     map_compact.UpdateMapPointersInRoots();
 
     PagedSpaces spaces;
     for (PagedSpace* space = spaces.next();
          space != NULL; space = spaces.next()) {
       if (space == Heap::map_space()) continue;
       map_compact.UpdateMapPointersInPagedSpace(space);
@@ skipping 557 matching lines @@
 }
 
 
 void MarkCompactCollector::Initialize() {
   StaticPointersToNewGenUpdatingVisitor::Initialize();
   StaticMarkingVisitor::Initialize();
 }
 
 
 } }  // namespace v8::internal