Disconnects code objects from infrequently used unoptimized functions.

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"
 #include "vm/object.h"
 #include "vm/virtual_memory.h"
 
 namespace dart {
 
 DEFINE_FLAG(int, heap_growth_space_ratio, 10,
             "The desired maximum percentage of free space after GC");
 DEFINE_FLAG(int, heap_growth_time_ratio, 3,
             "The desired maximum percentage of time spent in GC");
 DEFINE_FLAG(int, heap_growth_rate, 4,
             "The size the heap is grown, in heap pages");
 DEFINE_FLAG(bool, print_free_list_before_gc, false,
             "Print free list statistics before a GC");
 DEFINE_FLAG(bool, print_free_list_after_gc, false,
             "Print free list statistics after a GC");
+DEFINE_FLAG(bool, collect_code, true,
+            "Attempt to GC infrequently used code.");
+DEFINE_FLAG(int, code_collection_interval, 500000,
+            "Time between attempts to collect unused code.");
+DEFINE_FLAG(bool, log_code_drop, false,
+            "Emit a log message when pointers to unused code are dropped.");
 
 HeapPage* HeapPage::Initialize(VirtualMemory* memory, PageType type) {
   ASSERT(memory->size() > VirtualMemory::PageSize());
   bool is_executable = (type == kExecutable);
   memory->Commit(is_executable);
 
   HeapPage* result = reinterpret_cast<HeapPage*>(memory->address());
   result->memory_ = memory;
   result->next_ = NULL;
   result->executable_ = is_executable;
@@ skipping 335 matching lines @@
     page = page->next();
   }
   page = large_pages_;
   while (page != NULL) {
     page->WriteProtect(read_only);
     page = page->next();
   }
 }
 
 
+
+class CodeDetacherVisitor : public ObjectVisitor {
+ public:
+  explicit CodeDetacherVisitor(Isolate* isolate) : ObjectVisitor(isolate) { }
+
+  virtual void VisitObject(RawObject* obj);
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(CodeDetacherVisitor);
+};
+
+
+void CodeDetacherVisitor::VisitObject(RawObject* raw_obj) {
+  Isolate* isolate = Isolate::Current();
+  HANDLESCOPE(isolate);
+  const Object& obj = Object::Handle(raw_obj);
+  if (obj.GetClassId() == kFunctionCid) {
+    const Function& fn = Function::Cast(obj);
+    if (!fn.HasOptimizedCode() &&
+        !fn.HasBreakpoint() &&
+        (fn.CurrentCode() != Code::null()) &&  // Not already detached.

[srdjan, 2013/10/23 15:58:13]

fn.HasCode()

[zra, 2013/10/23 17:39:37]

Done.

+        (fn.usage_counter() > 0)) {
+      fn.set_usage_counter(fn.usage_counter() / 2);
+      if (fn.usage_counter() == 0) {
+        if (FLAG_log_code_drop) {
+          const String& name = String::Handle(fn.name());
+          OS::Print("Detaching code for function %s\n", name.ToCString());
+        }
+        fn.DetachCode();
+      }
+    }
+  }
+}
+
+
+void PageSpace::TryDetachingCode() {
+  // Try to collect code if enough time has passed since the last attempt.
+  const int64_t start = OS::GetCurrentTimeMicros();
+  const int64_t last_code_collection =
+      page_space_controller_.last_code_collection();
+  if ((start - last_code_collection) > FLAG_code_collection_interval) {
+    if (FLAG_log_code_drop) {
+      OS::Print("Trying to detach code.\n");
+    }
+    Isolate* isolate = Isolate::Current();
+    CodeDetacherVisitor code_detacher(isolate);
+    heap_->IterateObjects(&code_detacher);
+    page_space_controller_.set_last_code_collection(start);
+  }
+}
+
+
 void PageSpace::MarkSweep(bool invoke_api_callbacks) {
   // MarkSweep is not reentrant. Make sure that is the case.
   ASSERT(!sweeping_);
   sweeping_ = true;
   Isolate* isolate = Isolate::Current();
+  if (FLAG_collect_code) {
+    TryDetachingCode();
+  }
+
   NoHandleScope no_handles(isolate);
 
   if (FLAG_print_free_list_before_gc) {
     OS::Print("Data Freelist (before GC):\n");
     freelist_[HeapPage::kData].Print();
     OS::Print("Executable Freelist (before GC):\n");
     freelist_[HeapPage::kExecutable].Print();
   }
 
   if (FLAG_verify_before_gc) {
     OS::PrintErr("Verifying before MarkSweep...");
     heap_->Verify();
     OS::PrintErr(" done.\n");
   }
 
-  int64_t start = OS::GetCurrentTimeMicros();
+  const int64_t start = OS::GetCurrentTimeMicros();
 
   // Mark all reachable old-gen objects.
   GCMarker marker(heap_);
   marker.MarkObjects(isolate, this, invoke_api_callbacks);
 
   int64_t mid1 = OS::GetCurrentTimeMicros();
 
   // Reset the bump allocation page to unused.
   // Reset the freelists and setup sweeping.
   freelist_[HeapPage::kData].Reset();
@@ skipping 71 matching lines @@
 
 
 PageSpaceController::PageSpaceController(int heap_growth_ratio,
                                          int heap_growth_rate,
                                          int garbage_collection_time_ratio)
     : is_enabled_(false),
       grow_heap_(heap_growth_rate),
       heap_growth_ratio_(heap_growth_ratio),
       desired_utilization_((100.0 - heap_growth_ratio) / 100.0),
       heap_growth_rate_(heap_growth_rate),
-      garbage_collection_time_ratio_(garbage_collection_time_ratio) {
+      garbage_collection_time_ratio_(garbage_collection_time_ratio),
+      last_code_collection_(OS::GetCurrentTimeMicros()) {
 }
 
 
 PageSpaceController::~PageSpaceController() {}
 
 
 bool PageSpaceController::CanGrowPageSpace(intptr_t size_in_bytes) {
   size_in_bytes = Utils::RoundUp(size_in_bytes, PageSpace::kPageSize);
   intptr_t size_in_pages =  size_in_bytes / PageSpace::kPageSize;
   if (!is_enabled_) {
@@ skipping 82 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