Reapply r1900, r1897, r1895 with a fix....

src/spaces.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 93 matching lines @@
   Page* p = Page::FromAllocationTop(cur_addr_);
   ASSERT(p == Page::FromAllocationTop(cur_limit_));
   ASSERT(p->Offset(cur_addr_) <= p->Offset(cur_limit_));
 }
 #endif
 
 
 // -----------------------------------------------------------------------------
 // PageIterator
 
-PageIterator::PageIterator(PagedSpace* space, Mode mode) {
-  cur_page_ = space->first_page_;
+PageIterator::PageIterator(PagedSpace* space, Mode mode) : space_(space) {
+  prev_page_ = NULL;
   switch (mode) {
     case PAGES_IN_USE:
-      stop_page_ = space->AllocationTopPage()->next_page();
+      stop_page_ = space->AllocationTopPage();
       break;
     case PAGES_USED_BY_MC:
-      stop_page_ = space->MCRelocationTopPage()->next_page();
+      stop_page_ = space->MCRelocationTopPage();
       break;
     case ALL_PAGES:
-      stop_page_ = Page::FromAddress(NULL);
+      stop_page_ = space->last_page_;
       break;
     default:
       UNREACHABLE();
   }
 }
 
 
 // -----------------------------------------------------------------------------
 // Page
 
@@ skipping 354 matching lines @@
     if (!first_page_->is_valid()) return false;
   }
 
   // We are sure that the first page is valid and that we have at least one
   // page.
   ASSERT(first_page_->is_valid());
   ASSERT(num_pages > 0);
   accounting_stats_.ExpandSpace(num_pages * Page::kObjectAreaSize);
   ASSERT(Capacity() <= max_capacity_);
 
+  // Sequentially initialize remembered sets in the newly allocated
+  // pages and cache the current last page in the space.
   for (Page* p = first_page_; p->is_valid(); p = p->next_page()) {
     p->ClearRSet();
+    last_page_ = p;
   }
 
   // Use first_page_ for allocation.
   SetAllocationInfo(&allocation_info_, first_page_);
 
   return true;
 }
 
 
 bool PagedSpace::HasBeenSetup() {
@@ skipping 158 matching lines @@
 
   int desired_pages = Min(available_pages, MemoryAllocator::kPagesPerChunk);
   Page* p = MemoryAllocator::AllocatePages(desired_pages, &desired_pages, this);
   if (!p->is_valid()) return false;
 
   accounting_stats_.ExpandSpace(desired_pages * Page::kObjectAreaSize);
   ASSERT(Capacity() <= max_capacity_);
 
   MemoryAllocator::SetNextPage(last_page, p);
 
-  // Clear remembered set of new pages.
+  // Sequentially clear remembered set of new pages and and cache the
+  // new last page in the space.
   while (p->is_valid()) {
     p->ClearRSet();
+    last_page_ = p;
     p = p->next_page();
   }
 
   return true;
 }
 
 
 #ifdef DEBUG
 int PagedSpace::CountTotalPages() {
   int count = 0;
@@ skipping 24 matching lines @@
       last_page_to_keep = last_page_to_keep->next_page();
     }
     free_pages++;
     current_page = current_page->next_page();
   }
 
   // Free pages after last_page_to_keep, and adjust the next_page link.
   Page* p = MemoryAllocator::FreePages(last_page_to_keep->next_page());
   MemoryAllocator::SetNextPage(last_page_to_keep, p);
 
-  // Since pages are only freed in whole chunks, we may have kept more than
-  // pages_to_keep.
+  // Since pages are only freed in whole chunks, we may have kept more
+  // than pages_to_keep.  Count the extra pages and cache the new last
+  // page in the space.
+  last_page_ = last_page_to_keep;
   while (p->is_valid()) {
     pages_to_keep++;
+    last_page_ = p;
     p = p->next_page();
   }
 
   // The difference between free_pages and pages_to_keep is the number of
   // pages actually freed.
   ASSERT(pages_to_keep <= free_pages);
   int bytes_freed = (free_pages - pages_to_keep) * Page::kObjectAreaSize;
   accounting_stats_.ShrinkSpace(bytes_freed);
 
   ASSERT(Capacity() == CountTotalPages() * Page::kObjectAreaSize);
@@ skipping 1850 matching lines @@
                      reinterpret_cast<Object**>(object->address()
                                                 + Page::kObjectAreaSize),
                      allocation_top);
       PrintF("\n");
     }
   }
 }
 #endif  // DEBUG
 
 } }  // namespace v8::internal