Speedup profile generation for stress test benchmark by 176x

runtime/vm/pages.cc

 // Copyright (c) 2012, 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/pages.h"
 
 #include "platform/assert.h"
 #include "vm/compiler_stats.h"
 #include "vm/gc_marker.h"
 #include "vm/gc_sweeper.h"
@@ skipping 397 matching lines @@
   // TODO(koda): Control growth.
 }
 
 
 void PageSpace::FreeExternal(intptr_t size) {
   intptr_t size_in_words = size >> kWordSizeLog2;
   usage_.external_in_words -= size_in_words;
 }
 
 
-// Provides exclusive access to the pages, and ensures they are walkable.
+// Provides exclusive access to all pages, and ensures they are walkable.
 class ExclusivePageIterator : ValueObject {
  public:
   explicit ExclusivePageIterator(const PageSpace* space)
       : space_(space), ml_(space->pages_lock_) {
     space_->MakeIterable();
     page_ = space_->pages_;
     if (page_ == NULL) {
       page_ = space_->exec_pages_;
       if (page_ == NULL) {
         page_ = space_->large_pages_;
       }
     }
   }
   HeapPage* page() const { return page_; }
   bool Done() const { return page_ == NULL; }
   void Advance() {
     ASSERT(!Done());
     page_ = space_->NextPageAnySize(page_);
   }
  private:
   const PageSpace* space_;
   MutexLocker ml_;
   NoGCScope no_gc;
   HeapPage* page_;
 };
 
 
+// Provides exclusive access to code pages, and ensures they are walkable.
+// NOTE: This does not iterate over large pages which can contain code.
+class ExclusiveCodePageIterator : ValueObject {
+ public:
+  explicit ExclusiveCodePageIterator(const PageSpace* space)
+      : space_(space), ml_(space->pages_lock_) {
+    space_->MakeIterable();
+    page_ = space_->exec_pages_;
+  }
+  HeapPage* page() const { return page_; }
+  bool Done() const { return page_ == NULL; }
+  void Advance() {
+    ASSERT(!Done());
+    page_ = page_->next();
+  }
+ private:
+  const PageSpace* space_;
+  MutexLocker ml_;
+  NoGCScope no_gc;
+  HeapPage* page_;
+};
+
+
+// Provides exclusive access to large pages, and ensures they are walkable.
+class ExclusiveLargePageIterator : ValueObject {
+ public:
+  explicit ExclusiveLargePageIterator(const PageSpace* space)
+      : space_(space), ml_(space->pages_lock_) {
+    space_->MakeIterable();
+    page_ = space_->large_pages_;
+  }
+  HeapPage* page() const { return page_; }
+  bool Done() const { return page_ == NULL; }
+  void Advance() {
+    ASSERT(!Done());
+    page_ = page_->next();
+  }
+ private:
+  const PageSpace* space_;
+  MutexLocker ml_;
+  NoGCScope no_gc;
+  HeapPage* page_;
+};
+
+
 void PageSpace::MakeIterable() const {
   // TODO(koda): Assert not called from concurrent sweeper task.
   if (bump_top_ < bump_end_) {
     FreeListElement::AsElement(bump_top_, bump_end_ - bump_top_);
   }
 }
 
 
 bool PageSpace::Contains(uword addr) const {
   for (ExclusivePageIterator it(this); !it.Done(); it.Advance()) {
     if (it.page()->Contains(addr)) {
       return true;
     }
   }
   return false;
 }
 
 
 bool PageSpace::Contains(uword addr, HeapPage::PageType type) const {
+  if (type == HeapPage::kExecutable) {
+    // Fast path executable pages.
+    for (ExclusiveCodePageIterator it(this); !it.Done(); it.Advance()) {
+      if (it.page()->Contains(addr)) {
+        return true;
+      }
+    }
+    // Large pages can be executable, walk them too.
+    for (ExclusiveLargePageIterator it(this); !it.Done(); it.Advance()) {
+      if ((it.page()->type() == type) && it.page()->Contains(addr)) {
+        return true;
+      }
+    }
+    return false;
+  }
   for (ExclusivePageIterator it(this); !it.Done(); it.Advance()) {
     if ((it.page()->type() == type) && it.page()->Contains(addr)) {
       return true;
     }
   }
   return false;
 }
 
 
 void PageSpace::StartEndAddress(uword* start, uword* end) const {
@@ skipping 18 matching lines @@
 
 void PageSpace::VisitObjectPointers(ObjectPointerVisitor* visitor) const {
   for (ExclusivePageIterator it(this); !it.Done(); it.Advance()) {
     it.page()->VisitObjectPointers(visitor);
   }
 }
 
 
 RawObject* PageSpace::FindObject(FindObjectVisitor* visitor,
                                  HeapPage::PageType type) const {
+  if (type == HeapPage::kExecutable) {
+    // Fast path executable pages.
+    for (ExclusiveCodePageIterator it(this); !it.Done(); it.Advance()) {
+      RawObject* obj = it.page()->FindObject(visitor);
+      if (obj != Object::null()) {
+        return obj;
+      }
+    }
+    // Large pages can be executable, walk them too.
+    for (ExclusiveLargePageIterator it(this); !it.Done(); it.Advance()) {
+      if (it.page()->type() == type) {
+        RawObject* obj = it.page()->FindObject(visitor);
+        if (obj != Object::null()) {
+          return obj;
+        }
+      }
+    }
+    return Object::null();
+  }
+
   for (ExclusivePageIterator it(this); !it.Done(); it.Advance()) {
     if (it.page()->type() == type) {
       RawObject* obj = it.page()->FindObject(visitor);
       if (obj != Object::null()) {
         return obj;
       }
     }
   }
   return Object::null();
 }
@@ skipping 509 matching lines @@
     return 0;
   } else {
     ASSERT(total_time >= gc_time);
     int result = static_cast<int>((static_cast<double>(gc_time) /
                                    static_cast<double>(total_time)) * 100);
     return result;
   }
 }
 
 }  // namespace dart