- Implement the old sweeper.

vm/gc_marker.cc

 // Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/gc_marker.h"
 
 #include "vm/allocation.h"
 #include "vm/isolate.h"
 #include "vm/pages.h"
 #include "vm/raw_object.h"
@@ skipping 101 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(MarkingStack);
 };
 
 
 class MarkingVisitor : public ObjectPointerVisitor {
  public:
   MarkingVisitor(Heap* heap, PageSpace* page_space, MarkingStack* marking_stack)
       : heap_(heap),
         vm_heap_(Dart::vm_isolate()->heap()),
         page_space_(page_space),
-        marking_stack_(marking_stack) {}
+        marking_stack_(marking_stack) {
+    ASSERT(heap_ != vm_heap_);
+  }
 
   MarkingStack* marking_stack() const { return marking_stack_; }
 
   void VisitPointers(RawObject** first, RawObject** last) {
     for (RawObject** current = first; current <= last; current++) {
       MarkObject(*current);
     }
   }
 
  private:
   void MarkAndPush(RawObject* raw_obj) {
     ASSERT(raw_obj->IsHeapObject());
+    ASSERT(page_space_->Contains(RawObject::ToAddr(raw_obj)));
 
     // Mark the object and push it on the marking stack.
     ASSERT(!raw_obj->IsMarked());
     RawClass* raw_class = raw_obj->ptr()->class_;
     raw_obj->SetMarkBit();
     marking_stack_->Push(raw_obj);
 
+    // Update the number of used bytes on this page for fast accounting.
+    HeapPage* page = PageSpace::PageFor(raw_obj);
+    page->AddUsed(raw_obj->Size());
+
     // TODO(iposva): Should we mark the classes early?
     MarkObject(raw_class);
   }
 
   void MarkObject(RawObject* raw_obj) {
     // Fast exit if the raw object is a Smi.
     if (!raw_obj->IsHeapObject()) return;
 
     // Fast exit if the raw object is marked.
     if (raw_obj->IsMarked()) return;
 
     // Skip over new objects, but verify consistency of heap while at it.
     if (raw_obj->IsNewObject()) {
       // TODO(iposva): Add consistency check.
       return;
     }
 
     uword raw_addr = RawObject::ToAddr(raw_obj);
     // TODO(iposva): Premark vm_isolate objects, to avoid this extra check here.
     if (vm_heap_->Contains(raw_addr)) {
       return;
     }
     // TODO(iposva): merge old and code spaces.
-    // ASSERT(page_space_->Contains(raw_addr));
+    ASSERT(heap_->Contains(raw_addr));
+    if (!page_space_->Contains(raw_addr)) {
+      // TODO(iposva): Skip code space if marking data space and vice-versa.
+      return;
+    }
 
     MarkAndPush(raw_obj);
   }
 
   Heap* heap_;
   Heap* vm_heap_;
   PageSpace* page_space_;
   MarkingStack* marking_stack_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(MarkingVisitor);
 };
 
 
 void GCMarker::Prologue(Isolate* isolate) {
   // Nothing to do at the moment.
 }
 
 
 void GCMarker::IterateRoots(Isolate* isolate, MarkingVisitor* visitor) {
   isolate->VisitObjectPointers(visitor,
                                StackFrameIterator::kDontValidateFrames);
   heap_->IterateNewPointers(visitor);
+  heap_->IterateCodePointers(visitor);
 }
 
 
 void GCMarker::DrainMarkingStack(Isolate* isolate, MarkingVisitor* visitor) {
   while (!visitor->marking_stack()->IsEmpty()) {
     RawObject* raw_obj = visitor->marking_stack()->Pop();
     raw_obj->VisitPointers(visitor);
   }
 }
 
 
 void GCMarker::MarkObjects(Isolate* isolate, PageSpace* page_space) {
   MarkingStack marking_stack;
   Prologue(isolate);
   MarkingVisitor mark(heap_, page_space, &marking_stack);
   IterateRoots(isolate, &mark);
   DrainMarkingStack(isolate, &mark);
 }
 
 }  // namespace dart