[vm] Don't track allocation stats during marking in product mode.

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 "vm/allocation.h"
 #include "vm/dart_api_state.h"
 #include "vm/isolate.h"
 #include "vm/log.h"
@@ skipping 124 matching lines @@
  private:
   MarkingStack::Block* work_;
   MarkingStack* marking_stack_;
 };
 
 
 template <bool sync>
 class MarkingVisitorBase : public ObjectPointerVisitor {
  public:
   MarkingVisitorBase(Isolate* isolate,
-                     Heap* heap,
                      PageSpace* page_space,
                      MarkingStack* marking_stack,
                      SkippedCodeFunctions* skipped_code_functions)
       : ObjectPointerVisitor(isolate),
         thread_(Thread::Current()),
-        heap_(heap),
-        vm_heap_(Dart::vm_isolate()->heap()),
+#ifndef PRODUCT
         class_stats_count_(isolate->class_table()->NumCids()),
         class_stats_size_(isolate->class_table()->NumCids()),
+#endif  // !PRODUCT
         page_space_(page_space),
         work_list_(marking_stack),
         delayed_weak_properties_(NULL),
         visiting_old_object_(NULL),
         skipped_code_functions_(skipped_code_functions),
         marked_bytes_(0) {
-    ASSERT(heap_ != vm_heap_);
     ASSERT(thread_->isolate() == isolate);
+#ifndef PRODUCT
     class_stats_count_.SetLength(isolate->class_table()->NumCids());
     class_stats_size_.SetLength(isolate->class_table()->NumCids());
     for (intptr_t i = 0; i < class_stats_count_.length(); ++i) {
       class_stats_count_[i] = 0;
       class_stats_size_[i] = 0;
     }
+#endif  // !PRODUCT
   }
 
   uintptr_t marked_bytes() const { return marked_bytes_; }
 
+#ifndef PRODUCT
   intptr_t live_count(intptr_t class_id) {
     return class_stats_count_[class_id];
   }
 
   intptr_t live_size(intptr_t class_id) { return class_stats_size_[class_id]; }
+#endif  // !PRODUCT
 
   bool ProcessPendingWeakProperties() {
     bool marked = false;
     RawWeakProperty* cur_weak = delayed_weak_properties_;
     delayed_weak_properties_ = NULL;
     while (cur_weak != NULL) {
       uword next_weak = cur_weak->ptr()->next_;
       RawObject* raw_key = cur_weak->ptr()->key_;
       // Reset the next pointer in the weak property.
       cur_weak->ptr()->next_ = 0;
@@ skipping 158 matching lines @@
     // ...
     if (raw_obj->IsNewObject()) {
       ProcessNewSpaceObject(raw_obj, p);
       return;
     }
 
     if (!TryAcquireMarkBit(raw_obj)) {
       // Already marked.
       return;
     }
+
+#ifndef PRODUCT
     if (RawObject::IsVariableSizeClassId(raw_obj->GetClassId())) {
       UpdateLiveOld(raw_obj->GetClassId(), raw_obj->Size());
     } else {
       UpdateLiveOld(raw_obj->GetClassId(), 0);
     }
+#endif  // !PRODUCT
 
     PushMarked(raw_obj);
   }
 
   static bool TryAcquireRememberedBit(RawObject* raw_obj) {
     if (!sync) {
       if (raw_obj->IsRemembered()) return false;
       raw_obj->SetRememberedBitUnsynchronized();
       return true;
     }
     return raw_obj->TryAcquireRememberedBit();
   }
 
   void ProcessNewSpaceObject(RawObject* raw_obj, RawObject** p) {
     // TODO(iposva): Add consistency check.
     if ((visiting_old_object_ != NULL) &&
         TryAcquireRememberedBit(visiting_old_object_)) {
       // NOTE: We pass in the pointer to the address we are visiting
       // allows us to get a distance from the object start. At some
       // point we might want to store exact addresses in store buffers
       // for locations far enough from the header, so that we do not
       // need to walk big objects only to find the single new
       // reference in the last word during scavenge. This doesn't seem
       // to be a problem though currently.
       ASSERT(p != NULL);
       thread_->StoreBufferAddObjectGC(visiting_old_object_);
     }
   }
 
+#ifndef PRODUCT
   void UpdateLiveOld(intptr_t class_id, intptr_t size) {
     // TODO(koda): Support growing the array once mutator runs concurrently.
     ASSERT(class_id < class_stats_count_.length());
     class_stats_count_[class_id] += 1;
     class_stats_size_[class_id] += size;
   }
+#endif  // !PRODUCT
 
   Thread* thread_;
-  Heap* heap_;
-  Heap* vm_heap_;
+#ifndef PRODUCT
   GrowableArray<intptr_t> class_stats_count_;
   GrowableArray<intptr_t> class_stats_size_;
+#endif  // !PRODUCT
   PageSpace* page_space_;
   MarkerWorkList work_list_;
   RawWeakProperty* delayed_weak_properties_;
   RawObject* visiting_old_object_;
   SkippedCodeFunctions* skipped_code_functions_;
   uintptr_t marked_bytes_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(MarkingVisitorBase);
 };
 
@@ skipping 153 matching lines @@
     bool result =
         Thread::EnterIsolateAsHelper(isolate_, Thread::kMarkerTask, true);
     ASSERT(result);
     {
       Thread* thread = Thread::Current();
       TIMELINE_FUNCTION_GC_DURATION(thread, "MarkTask");
       StackZone stack_zone(thread);
       Zone* zone = stack_zone.GetZone();
       SkippedCodeFunctions* skipped_code_functions =
           collect_code_ ? new (zone) SkippedCodeFunctions() : NULL;
-      SyncMarkingVisitor visitor(isolate_, heap_, page_space_, marking_stack_,
+      SyncMarkingVisitor visitor(isolate_, page_space_, marking_stack_,
                                  skipped_code_functions);
       // Phase 1: Iterate over roots and drain marking stack in tasks.
       marker_->IterateRoots(isolate_, &visitor, task_index_, num_tasks_);
 
       bool more_to_mark = false;
       do {
         do {
           visitor.DrainMarkingStack();
 
           // I can't find more work right now. If no other task is busy,
@@ skipping 109 matching lines @@
     Thread* thread = Thread::Current();
     StackZone stack_zone(thread);
     Zone* zone = stack_zone.GetZone();
     MarkingStack marking_stack;
     marked_bytes_ = 0;
     const int num_tasks = FLAG_marker_tasks;
     if (num_tasks == 0) {
       // Mark everything on main thread.
       SkippedCodeFunctions* skipped_code_functions =
           collect_code ? new (zone) SkippedCodeFunctions() : NULL;
-      UnsyncMarkingVisitor mark(isolate, heap_, page_space, &marking_stack,
+      UnsyncMarkingVisitor mark(isolate, page_space, &marking_stack,
                                 skipped_code_functions);
       IterateRoots(isolate, &mark, 0, 1);
       mark.DrainMarkingStack();
       {
         TIMELINE_FUNCTION_GC_DURATION(thread, "WeakHandleProcessing");
         MarkingWeakVisitor mark_weak(thread);
         IterateWeakRoots(isolate, &mark_weak);
       }
       // All marking done; detach code, etc.
       FinalizeResultsFrom(&mark);
@@ skipping 42 matching lines @@
       // Phase 3: Finalize results from all markers (detach code, etc.).
       barrier.Exit();
     }
     ProcessWeakTables(page_space);
     ProcessObjectIdTable(isolate);
   }
   Epilogue(isolate, invoke_api_callbacks);
 }
 
 }  // namespace dart