Get rid of distinction between below- and above-watermark in page allocation....

src/profile-generator.cc

 // Copyright 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 1793 matching lines @@
                              retainers_count);
 }
 
 
 void V8HeapExplorer::AddRootEntries(SnapshotFillerInterface* filler) {
   filler->AddEntry(kInternalRootObject, this);
   filler->AddEntry(kGcRootsObject, this);
 }
 
 
-int V8HeapExplorer::EstimateObjectsCount() {
-  HeapIterator iterator(HeapIterator::kFilterUnreachable);
+int V8HeapExplorer::EstimateObjectsCount(HeapIterator* iterator) {
   int objects_count = 0;
-  for (HeapObject* obj = iterator.next();
+  for (HeapObject* obj = iterator->Next();
        obj != NULL;
-       obj = iterator.next(), ++objects_count) {}
+       obj = iterator->Next(), ++objects_count) {}
   return objects_count;
 }
 
 
 class IndexedReferencesExtractor : public ObjectVisitor {
  public:
   IndexedReferencesExtractor(V8HeapExplorer* generator,
                              HeapObject* parent_obj,
                              HeapEntry* parent_entry,
                              HeapObjectsSet* known_references = NULL)
@@ skipping 178 matching lines @@
   }
   void VisitPointers(Object** start, Object** end) {
     for (Object** p = start; p < end; p++) explorer_->SetGcRootsReference(*p);
   }
  private:
   V8HeapExplorer* explorer_;
 };
 
 
 bool V8HeapExplorer::IterateAndExtractReferences(
+    HeapIterator* iterator,
     SnapshotFillerInterface* filler) {
   filler_ = filler;
-  HeapIterator iterator(HeapIterator::kFilterUnreachable);
   bool interrupted = false;
   // Heap iteration with filtering must be finished in any case.
-  for (HeapObject* obj = iterator.next();
+  for (HeapObject* obj = iterator->Next();
        obj != NULL;
-       obj = iterator.next(), progress_->ProgressStep()) {
+       obj = iterator->Next(), progress_->ProgressStep()) {
     if (!interrupted) {
       ExtractReferences(obj);
       if (!progress_->ProgressReport(false)) interrupted = true;
     }
   }
   if (interrupted) {
     filler_ = NULL;
     return false;
   }
   SetRootGcRootsReference();
@@ skipping 465 matching lines @@
                               retainer_index);
   }
  private:
   HeapSnapshot* snapshot_;
   HeapSnapshotsCollection* collection_;
   HeapEntriesMap* entries_;
 };
 
 
 bool HeapSnapshotGenerator::GenerateSnapshot() {
+  HeapIterator set_progress_heap_iterator;
+  HeapIterator count_entries_heap_iterator;
+  HeapIterator fill_references_heap_iterator;
   AssertNoAllocation no_alloc;
 
-  SetProgressTotal(4);  // 2 passes + dominators + sizes.
+  SetProgressTotal(&set_progress_heap_iterator,
+                   4);  // 2 passes + dominators + sizes.
 
   // Pass 1. Iterate heap contents to count entries and references.
-  if (!CountEntriesAndReferences()) return false;
+  if (!CountEntriesAndReferences(&count_entries_heap_iterator)) return false;
 
   // Allocate and fill entries in the snapshot, allocate references.
   snapshot_->AllocateEntries(entries_.entries_count(),
                              entries_.total_children_count(),
                              entries_.total_retainers_count());
   entries_.AllocateEntries();
 
   // Pass 2. Fill references.
-  if (!FillReferences()) return false;
+  if (!FillReferences(&fill_references_heap_iterator)) return false;
 
   if (!SetEntriesDominators()) return false;
   if (!ApproximateRetainedSizes()) return false;
 
   progress_counter_ = progress_total_;
   if (!ProgressReport(true)) return false;
   return true;
 }
 
 
 void HeapSnapshotGenerator::ProgressStep() {
   ++progress_counter_;
 }
 
 
 bool HeapSnapshotGenerator::ProgressReport(bool force) {
   const int kProgressReportGranularity = 10000;
   if (control_ != NULL
       && (force || progress_counter_ % kProgressReportGranularity == 0)) {
       return
           control_->ReportProgressValue(progress_counter_, progress_total_) ==
           v8::ActivityControl::kContinue;
   }
   return true;
 }
 
 
-void HeapSnapshotGenerator::SetProgressTotal(int iterations_count) {
+void HeapSnapshotGenerator::SetProgressTotal(HeapIterator* iterator,
+                                             int iterations_count) {
   if (control_ == NULL) return;
   progress_total_ = (
-      v8_heap_explorer_.EstimateObjectsCount() +
+      v8_heap_explorer_.EstimateObjectsCount(iterator) +
       dom_explorer_.EstimateObjectsCount()) * iterations_count;
   progress_counter_ = 0;
 }
 
 
-bool HeapSnapshotGenerator::CountEntriesAndReferences() {
+bool HeapSnapshotGenerator::CountEntriesAndReferences(HeapIterator* iterator) {
   SnapshotCounter counter(&entries_);
   v8_heap_explorer_.AddRootEntries(&counter);
   dom_explorer_.AddRootEntries(&counter);
   return
-      v8_heap_explorer_.IterateAndExtractReferences(&counter) &&
+      v8_heap_explorer_.IterateAndExtractReferences(iterator, &counter) &&
       dom_explorer_.IterateAndExtractReferences(&counter);
 }
 
 
-bool HeapSnapshotGenerator::FillReferences() {
+bool HeapSnapshotGenerator::FillReferences(HeapIterator* iterator) {
   SnapshotFiller filler(snapshot_, &entries_);
   return
-      v8_heap_explorer_.IterateAndExtractReferences(&filler) &&
+      v8_heap_explorer_.IterateAndExtractReferences(iterator, &filler) &&
       dom_explorer_.IterateAndExtractReferences(&filler);
 }
 
 
 void HeapSnapshotGenerator::FillReversePostorderIndexes(
     Vector<HeapEntry*>* entries) {
   snapshot_->ClearPaint();
   int current_entry = 0;
   List<HeapEntry*> nodes_to_visit;
   nodes_to_visit.Add(snapshot_->root());
@@ skipping 561 matching lines @@
 
 
 String* GetConstructorNameForHeapProfile(JSObject* object) {
   if (object->IsJSFunction()) return Heap::closure_symbol();
   return object->constructor_name();
 }
 
 } }  // namespace v8::internal
 
 #endif  // ENABLE_LOGGING_AND_PROFILING