Perform TODO(gc) cleanup for TODO-lockdown.

src/mark-compact.cc

 // 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 345 matching lines @@
 #endif
     if (Marking::IsBlack(old_mark_bit)) {
       Marking::MarkBlack(new_mark_bit);
       old_mark_bit.Clear();
       return true;
     } else if (Marking::IsGrey(old_mark_bit)) {
       old_mark_bit.Next().Clear();
       heap_->incremental_marking()->WhiteToGreyAndPush(
           HeapObject::FromAddress(new_start), new_mark_bit);
       heap_->incremental_marking()->RestartIfNotMarking();
-      // TODO(gc): if we shift huge array in the loop we might end up pushing
-      // too much into the marking deque. Maybe we should check one or two
-      // elements on top/bottom of the marking deque to see whether they are
-      // equal to old_start.
     }
 
 #ifdef DEBUG
     ObjectColor new_color = Color(new_mark_bit);
     ASSERT(new_color == old_color);
 #endif
     return false;
   }
   MarkBit old_mark_bit = MarkBitFrom(old_start);
   if (!old_mark_bit.Get()) {
@@ skipping 15 matching lines @@
     if (space->IsFragmented(p)) {
       AddEvacuationCandidate(p);
     } else {
       p->ClearEvacuationCandidate();
     }
   }
 }
 
 
 void MarkCompactCollector::Prepare(GCTracer* tracer) {
-  // TODO(gc) re-enable code flushing.
   FLAG_flush_code = false;
   FLAG_always_compact = false;
 
   // Disable collection of maps if incremental marking is enabled.
-  // TODO(gc) improve maps collection algorithm to work with incremental
-  // marking.
-  // TODO(gc) consider oscillating collect_maps_ on and off when possible. This
-  // will allow map transition trees to die from both root and leaves.
+  // Map collection algorithm relies on a special map transition tree traversal
+  // order which is not implemented for incremental marking.

[Erik Corry, 2011/08/16 11:17:20]

Do we have a bug number for map collection?

   collect_maps_ = FLAG_collect_maps &&
       !heap()->incremental_marking()->IsMarking();
 
   // Rather than passing the tracer around we stash it in a static member
   // variable.
   tracer_ = tracer;
 
 #ifdef DEBUG
   ASSERT(state_ == IDLE);
   state_ = PREPARE_GC;
@@ skipping 223 matching lines @@
 
   Object* second = reinterpret_cast<ConsString*>(object)->unchecked_second();
   Heap* heap = map->GetHeap();
   if (second != heap->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.
-  // TODO(gc): Seems like we could relax this restriction with store buffers.
   Object* first = reinterpret_cast<ConsString*>(object)->unchecked_first();
   if (!heap->InNewSpace(object) && heap->InNewSpace(first)) return object;
 
   *p = first;
   return HeapObject::cast(first);
 }
 
 
 class StaticMarkingVisitor : public StaticVisitorBase {
  public:
@@ skipping 1498 matching lines @@
       // Fill slots that became free with undefined value.
       Object* undefined = heap()->undefined_value();
       for (int i = new_number_of_transitions * step;
            i < number_of_transitions * step;
            i++) {
         prototype_transitions->set_unchecked(heap_,
                                              header + i,
                                              undefined,
                                              SKIP_WRITE_BARRIER);
 
-        // TODO(gc) we should not evacuate first page of data space.
-        // but we are doing it now to increase coverage.
         Object** undefined_slot =
             prototype_transitions->data_start() + i;
         RecordSlot(undefined_slot, undefined_slot, undefined);
       }
       map->SetNumberOfProtoTransitions(new_number_of_transitions);
     }
 
     // Follow the chain of back pointers to find the prototype.
     Map* current = map;
     while (current->IsMap()) {
@@ skipping 206 matching lines @@
   return String::cast(*p);
 }
 
 
 bool MarkCompactCollector::TryPromoteObject(HeapObject* object,
                                             int object_size) {
   Object* result;
 
   if (object_size > heap()->MaxObjectSizeInPagedSpace()) {
     MaybeObject* maybe_result =
-        heap()->lo_space()->AllocateRawFixedArray(object_size);
+        heap()->lo_space()->AllocateRaw(object_size, NOT_EXECUTABLE);
     if (maybe_result->ToObject(&result)) {
       HeapObject* target = HeapObject::cast(result);
       MigrateObject(target->address(),
                     object->address(),
                     object_size,
                     LO_SPACE);
       heap()->mark_compact_collector()->tracer()->
           increment_promoted_objects_size(object_size);
       return true;
     }
@@ skipping 189 matching lines @@
       if (map_word.IsForwardingAddress()) {
         *slot = map_word.ToForwardingAddress();
         ASSERT(!MarkCompactCollector::IsOnEvacuationCandidate(*slot));
       }
     }
   }
 }
 
 
 static void UpdateSlotsOnPage(Page* p, ObjectVisitor* visitor) {
-  // TODO(gc) this is basically clone of SweepPrecisely
   PagedSpace* space = static_cast<PagedSpace*>(p->owner());
   MarkBit::CellType* cells = p->markbits()->cells();
 
   p->ClearFlag(MemoryChunk::WAS_SWEPT_CONSERVATIVELY);
   p->ClearFlag(MemoryChunk::RESCAN_ON_EVACUATION);
   p->MarkSwept();
 
   int last_cell_index =
       Bitmap::IndexToCell(
           Bitmap::CellAlignIndex(
@@ skipping 622 matching lines @@
     }
 
     switch (sweeper) {
       case CONSERVATIVE: {
         SweepConservatively(space, p);
         break;
       }
       case LAZY_CONSERVATIVE: {
         Page* next_page = p->next_page();
         freed_bytes += SweepConservatively(space, p);
-        // TODO(gc): tweak the heuristic.
         if (freed_bytes >= newspace_size && p != space->LastPage()) {
           space->SetPagesToSweep(next_page, space->LastPage());
           return;
         }
         break;
       }
       case PRECISE: {
         SweepPrecisely(space, p);
         break;
       }
       default: {
         UNREACHABLE();
       }
     }
   }
-
-  // TODO(gc): set up allocation top and limit using the free list.
 }
 
 
 void MarkCompactCollector::SweepSpaces() {
   GCTracer::Scope gc_scope(tracer_, GCTracer::Scope::MC_SWEEP);
 #ifdef DEBUG
   state_ = SWEEP_SPACES;
 #endif
   SweeperType how_to_sweep =
       FLAG_lazy_sweeping ? LAZY_CONSERVATIVE : CONSERVATIVE;
   if (sweep_precisely_) how_to_sweep = PRECISE;
   // Noncompacting collections simply sweep the spaces to clear the mark
   // bits and free the nonlive blocks (for old and map spaces).  We sweep
   // the map space last because freeing non-live maps overwrites them and
   // the other spaces rely on possibly non-live maps to get the sizes for
   // non-live objects.
   SweepSpace(heap()->old_pointer_space(), how_to_sweep);
   SweepSpace(heap()->old_data_space(), how_to_sweep);
   SweepSpace(heap()->code_space(), PRECISE);
-  // TODO(gc): implement specialized sweeper for cell space.
   SweepSpace(heap()->cell_space(), PRECISE);
   { GCTracer::Scope gc_scope(tracer_, GCTracer::Scope::MC_SWEEP_NEWSPACE);
     EvacuateNewSpaceAndCandidates();
   }
-  // TODO(gc): ClearNonLiveTransitions depends on precise sweeping of
-  // map space to detect whether unmarked map became dead in this
-  // collection or in one of the previous ones.
-  // TODO(gc): Implement specialized sweeper for map space.
+  // ClearNonLiveTransitions depends on precise sweeping of map space to
+  // detect whether unmarked map became dead in this collection or in one
+  // of the previous ones.
   SweepSpace(heap()->map_space(), PRECISE);
 
   ASSERT(live_map_objects_size_ <= heap()->map_space()->Size());
 
   // Deallocate unmarked objects and clear marked bits for marked objects.
   heap_->lo_space()->FreeUnmarkedObjects();
 }
 
 
-// Iterate the live objects in a range of addresses (eg, a page or a
-// semispace).  The live regions of the range have been linked into a list.
-// The first live region is [first_live_start, first_live_end), and the last
-// address in the range is top.  The callback function is used to get the
-// size of each live object.
-int MarkCompactCollector::IterateLiveObjectsInRange(
-    Address start,
-    Address end,
-    LiveObjectCallback size_func) {
-  int live_objects_size = 0;
-  Address current = start;
-  while (current < end) {
-    uint32_t encoded_map = Memory::uint32_at(current);
-    if (encoded_map == kSingleFreeEncoding) {
-      current += kPointerSize;
-    } else if (encoded_map == kMultiFreeEncoding) {
-      current += Memory::int_at(current + kIntSize);
-    } else {
-      int size = (this->*size_func)(HeapObject::FromAddress(current));
-      current += size;
-      live_objects_size += size;
-    }
-  }
-  return live_objects_size;
-}
-
-
-int MarkCompactCollector::IterateLiveObjects(
-    NewSpace* space, LiveObjectCallback size_f) {
-  ASSERT(MARK_LIVE_OBJECTS < state_ && state_ <= RELOCATE_OBJECTS);
-  int accumulator = 0;
-  Address end = space->top();
-  NewSpacePageIterator it(space->bottom(), end);
-  // The bottom is at the start of its page.
-  ASSERT_EQ(space->bottom(),
-            NewSpacePage::FromAddress(space->bottom())->body());
-  while (it.has_next()) {
-    NewSpacePage* page = it.next();
-    Address start = page->body();
-    Address limit = it.has_next() ? page->body_limit() : end;
-    accumulator += IterateLiveObjectsInRange(start, limit, size_f);
-  }
-  return accumulator;
-}
-
-
-int MarkCompactCollector::IterateLiveObjects(
-    PagedSpace* space, LiveObjectCallback size_f) {
-  ASSERT(MARK_LIVE_OBJECTS < state_ && state_ <= RELOCATE_OBJECTS);
-  // TODO(gc): Do a mark-sweep first with precise sweeping.
-  int total = 0;
-  PageIterator it(space);
-  while (it.has_next()) {
-    Page* p = it.next();
-    total += IterateLiveObjectsInRange(p->ObjectAreaStart(),
-                                       p->ObjectAreaEnd(),
-                                       size_f);
-  }
-  return total;
-}
-
-
-// TODO(gc) ReportDeleteIfNeeded is not called currently.
+// TODO(1466) ReportDeleteIfNeeded is not called currently.
 // Our profiling tools do not expect intersections between
 // code objects. We should either reenable it or change our tools.
 void MarkCompactCollector::EnableCodeFlushing(bool enable) {
   if (enable) {
     if (code_flusher_ != NULL) return;
     code_flusher_ = new CodeFlusher(heap()->isolate());
   } else {
     if (code_flusher_ == NULL) return;
     delete code_flusher_;
     code_flusher_ = NULL;
@@ skipping 20 matching lines @@
 
 
 void SlotsBuffer::UpdateSlots() {
   for (int slot_idx = 0; slot_idx < idx_; ++slot_idx) {
     UpdateSlot(slots_[slot_idx]);
   }
 }
 
 
 SlotsBuffer* SlotsBufferAllocator::AllocateBuffer(SlotsBuffer* next_buffer) {
-  // TODO(gc) Consider maintaining local cache of buffers.
   return new SlotsBuffer(next_buffer);
 }
 
 
 void SlotsBufferAllocator::DeallocateBuffer(SlotsBuffer* buffer) {
   delete buffer;
 }
 
 
 void SlotsBufferAllocator::DeallocateChain(SlotsBuffer** buffer_address) {
   SlotsBuffer* buffer = *buffer_address;
   while (buffer != NULL) {
     SlotsBuffer* next_buffer = buffer->next();
     DeallocateBuffer(buffer);
     buffer = next_buffer;
   }
   *buffer_address = NULL;
 }
 
 
 } }  // namespace v8::internal