VM: Enable collection of unoptimized code for optimized functions.

runtime/vm/gc_marker.cc

 // Copyright (c) 2011, 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/gc_marker.h"
 
 #include <map>
 #include <utility>
 #include <vector>
 
 #include "vm/allocation.h"
 #include "vm/dart_api_state.h"
 #include "vm/isolate.h"
+#include "vm/log.h"
 #include "vm/pages.h"
 #include "vm/raw_object.h"
 #include "vm/stack_frame.h"
 #include "vm/visitor.h"
 #include "vm/object_id_ring.h"
 
 namespace dart {
 
 // A simple chunked marking stack.
 class MarkingStack : public ValueObject {
@@ skipping 116 matching lines @@
   MarkingStack* marking_stack() const { return marking_stack_; }
 
   void VisitPointers(RawObject** first, RawObject** last) {
     for (RawObject** current = first; current <= last; current++) {
       MarkObject(*current, current);
     }
   }
 
   bool visit_function_code() const { return visit_function_code_; }
 
-  GrowableArray<RawFunction*>* skipped_code_functions() {
-    return &skipped_code_functions_;
+  virtual GrowableArray<RawFunction*>* skipped_current_code_functions() {
+    return &skipped_current_code_functions_;

[Vyacheslav Egorov (Google), 2015/04/09 12:23:07]

I think there is no reason to have two separate lists. Just use the same list
and check if any of the two code objects need to be dropped.

[Florian Schneider, 2015/04/09 14:58:43]

Done.

+  }
+
+  virtual GrowableArray<RawFunction*>* skipped_unoptimized_code_functions() {
+    return &skipped_unoptimized_code_functions_;
   }
 
   void DelayWeakProperty(RawWeakProperty* raw_weak) {
     RawObject* raw_key = raw_weak->ptr()->key_;
     DelaySet::iterator it = delay_set_.find(raw_key);
     if (it != delay_set_.end()) {
       ASSERT(raw_key->IsWatched());
     } else {
       ASSERT(!raw_key->IsWatched());
       raw_key->SetWatchedBitUnsynchronized();
@@ skipping 70 matching lines @@
     if (RawObject::IsVariableSizeClassId(raw_obj->GetClassId())) {
       class_table_->UpdateLiveOld(raw_obj->GetClassId(), raw_obj->Size());
     } else {
       class_table_->UpdateLiveOld(raw_obj->GetClassId(), 0);
     }
 
     MarkAndPush(raw_obj);
   }
 
   void DetachCode() {
-    for (int i = 0; i < skipped_code_functions_.length(); i++) {
-      RawFunction* func = skipped_code_functions_[i];
+    intptr_t unoptimized_code_count = 0;
+    intptr_t current_code_count = 0;
+    for (int i = 0; i < skipped_current_code_functions_.length(); i++) {
+      RawFunction* func = skipped_current_code_functions_[i];
       RawCode* code = func->ptr()->instructions_->ptr()->code_;
       if (!code->IsMarked()) {
         // If the code wasn't strongly visited through other references
         // after skipping the function's code pointer, then we disconnect the
         // code from the function.
         StubCode* stub_code = isolate()->stub_code();
         func->StorePointer(
             &(func->ptr()->instructions_),
             stub_code->LazyCompile_entry()->code()->ptr()->instructions_);
-        func->StorePointer(&(func->ptr()->unoptimized_code_), Code::null());
         if (FLAG_log_code_drop) {
           // NOTE: This code runs while GC is in progress and runs within
           // a NoHandleScope block. Hence it is not okay to use a regular Zone
           // or Scope handle. We use a direct stack handle so the raw pointer in
           // this handle is not traversed. The use of a handle is mainly to
           // be able to reuse the handle based code and avoid having to add
           // helper functions to the raw object interface.
           String name;
           name = func->ptr()->name_;
-          OS::Print("Detaching code: %s\n", name.ToCString());
+          ISL_Print("Detaching code: %s\n", name.ToCString());
+          current_code_count++;
         }
       }
     }
+    for (int i = 0; i < skipped_unoptimized_code_functions_.length(); i++) {
+      RawFunction* func = skipped_unoptimized_code_functions_[i];
+      RawCode* code = func->ptr()->unoptimized_code_;
+      if (!code->IsMarked()) {
+        // If the code wasn't strongly visited through other references
+        // after skipping the function's code pointer, then we disconnect the
+        // code from the function.
+        func->StorePointer(&(func->ptr()->unoptimized_code_), Code::null());
+        if (FLAG_log_code_drop) {
+          unoptimized_code_count++;
+        }
+      }
+    }
+    if (FLAG_log_code_drop) {
+      ISL_Print("  total detached current: %" Pd "\n", current_code_count);
+      ISL_Print("  total detached unoptimized: %" Pd "\n",
+                unoptimized_code_count);
+    }
   }
 
   Heap* heap_;
   Heap* vm_heap_;
   ClassTable* class_table_;
   PageSpace* page_space_;
   MarkingStack* marking_stack_;
   RawObject* visiting_old_object_;
   typedef std::multimap<RawObject*, RawWeakProperty*> DelaySet;
   typedef std::pair<RawObject*, RawWeakProperty*> DelaySetEntry;
   DelaySet delay_set_;
   const bool visit_function_code_;
-  GrowableArray<RawFunction*> skipped_code_functions_;
+  GrowableArray<RawFunction*> skipped_current_code_functions_;
+  GrowableArray<RawFunction*> skipped_unoptimized_code_functions_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(MarkingVisitor);
 };
 
 
 static bool IsUnreachable(const RawObject* raw_obj) {
   if (!raw_obj->IsHeapObject()) {
     return false;
   }
   if (raw_obj == Object::null()) {
@@ skipping 225 matching lines @@
     MarkingWeakVisitor mark_weak;
     IterateWeakRoots(isolate, &mark_weak, invoke_api_callbacks);
     mark.Finalize();
     ProcessWeakTables(page_space);
     ProcessObjectIdTable(isolate);
   }
   Epilogue(isolate, invoke_api_callbacks);
 }
 
 }  // namespace dart