Basic implementation of incremental marking.

src/spaces.cc

 // Copyright 2006-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 56 matching lines @@
 void HeapObjectIterator::Initialize(Address cur, Address end,
                                     HeapObjectCallback size_f) {
   cur_addr_ = cur;
   end_addr_ = end;
   end_page_ = Page::FromAllocationTop(end);
   size_func_ = size_f;
   Page* p = Page::FromAllocationTop(cur_addr_);
   cur_limit_ = (p == end_page_) ? end_addr_ : p->AllocationTop();
 
   if (!p->IsFlagSet(Page::IS_CONTINUOUS)) {
+    ASSERT(IncrementalMarking::state() == IncrementalMarking::STOPPED);
     cur_addr_ = Marking::FirstLiveObject(cur_addr_, cur_limit_);
     if (cur_addr_ > cur_limit_) cur_addr_ = cur_limit_;
   }
 
 #ifdef DEBUG
   Verify();
 #endif
 }
 
 
 HeapObject* HeapObjectIterator::FromNextPage() {
   if (cur_addr_ == end_addr_) return NULL;
 
   Page* cur_page = Page::FromAllocationTop(cur_addr_);
   cur_page = cur_page->next_page();
   ASSERT(cur_page->is_valid());
 
   cur_addr_ = cur_page->ObjectAreaStart();
   cur_limit_ = (cur_page == end_page_) ? end_addr_ : cur_page->AllocationTop();
 
   if (!cur_page->IsFlagSet(Page::IS_CONTINUOUS)) {
+    ASSERT(IncrementalMarking::state() == IncrementalMarking::STOPPED);
     cur_addr_ = Marking::FirstLiveObject(cur_addr_, cur_limit_);
     if (cur_addr_ > cur_limit_) cur_addr_ = cur_limit_;
   }
 
   if (cur_addr_ == end_addr_) return NULL;
   ASSERT(cur_addr_ < cur_limit_);
 #ifdef DEBUG
   Verify();
 #endif
   return FromCurrentPage();
 }
 
 
 void HeapObjectIterator::AdvanceUsingMarkbits() {
+  ASSERT(IncrementalMarking::state() == IncrementalMarking::STOPPED);
   HeapObject* obj = HeapObject::FromAddress(cur_addr_);
   int obj_size = (size_func_ == NULL) ? obj->Size() : size_func_(obj);
   ASSERT_OBJECT_SIZE(obj_size);
   cur_addr_ = Marking::NextLiveObject(obj,
                                       obj_size,
                                       cur_limit_);
   if (cur_addr_ > cur_limit_) cur_addr_ = cur_limit_;
 }
 
 
@@ skipping 2181 matching lines @@
                                                        this);
   if (page == NULL) return Failure::RetryAfterGC(identity());
   ASSERT(page->body_size() >= object_size);
 
   size_ += static_cast<int>(page->size());
   objects_size_ += object_size;
   page_count_++;
   page->set_next_page(first_page_);
   first_page_ = page;
 
+
+  IncrementalMarking::Step(object_size);
   return page->GetObject();
 }
 
 
 MaybeObject* LargeObjectSpace::AllocateRawCode(int size_in_bytes) {
   ASSERT(0 < size_in_bytes);
   return AllocateRawInternal(size_in_bytes, EXECUTABLE);
 }
 
 
@@ skipping 184 matching lines @@
   for (HeapObject* obj = obj_it.next(); obj != NULL; obj = obj_it.next()) {
     if (obj->IsCode()) {
       Code* code = Code::cast(obj);
       code_kind_statistics[code->kind()] += code->Size();
     }
   }
 }
 #endif  // DEBUG
 
 } }  // namespace v8::internal