VM: Store edge counters in one per-function array.

runtime/vm/flow_graph_compiler.cc

 // Copyright (c) 2013, 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/globals.h"  // Needed here to get TARGET_ARCH_XXX.
 
 #include "vm/flow_graph_compiler.h"
 
 #include "vm/bit_vector.h"
 #include "vm/cha.h"
@@ skipping 181 matching lines @@
         mint_class_(Class::ZoneHandle(
             isolate_->object_store()->mint_class())),
         float32x4_class_(Class::ZoneHandle(
             isolate_->object_store()->float32x4_class())),
         float64x2_class_(Class::ZoneHandle(
             isolate_->object_store()->float64x2_class())),
         int32x4_class_(Class::ZoneHandle(
             isolate_->object_store()->int32x4_class())),
         list_class_(Class::ZoneHandle(
             Library::Handle(Library::CoreLibrary()).
                 LookupClass(Symbols::List()))),

[siva, 2015/09/26 00:18:32]

I was wondering if it make sense to store these in the isolate instead of here
because it needs to be done just once for an isolate.

[Florian Schneider, 2015/09/28 09:19:43]

Maybe. On the other hand they are only needed for compilation and cached here to
avoid creating too many ZoneHandles.

[siva, 2015/09/28 17:01:29]

Agreed it is done once per compilation but we have numerous compilations that
happen in an isolate and doing it once per isolate would save a bit of the per
compilation overhead cost.

         parallel_move_resolver_(this),
         pending_deoptimization_env_(NULL),
         entry_patch_pc_offset_(Code::kInvalidPc),
         patch_code_pc_offset_(Code::kInvalidPc),
         lazy_deopt_pc_offset_(Code::kInvalidPc),
         deopt_id_to_ic_data_(NULL),
+        edge_counters_array_(Array::ZoneHandle()),
         inlined_code_intervals_(Array::ZoneHandle(Object::empty_array().raw())),
         inline_id_to_function_(inline_id_to_function),
         caller_inline_id_(caller_inline_id) {
   ASSERT(flow_graph->parsed_function().function().raw() ==
          parsed_function.function().raw());
   if (!is_optimizing) {
     const intptr_t len = isolate()->deopt_id();
     deopt_id_to_ic_data_ = new(zone()) ZoneGrowableArray<const ICData*>(len);
     deopt_id_to_ic_data_->SetLength(len);
     for (intptr_t i = 0; i < len; i++) {
       (*deopt_id_to_ic_data_)[i] = NULL;
     }
-    const Array& old_saved_icdata = Array::Handle(zone(),
+    // TODO(fschneider): Abstract iteration into ICDataArrayIterator.
+    const Array& old_saved_ic_data = Array::Handle(zone(),
         flow_graph->function().ic_data_array());
     const intptr_t saved_len =
-        old_saved_icdata.IsNull() ? 0 : old_saved_icdata.Length();
-    for (intptr_t i = 0; i < saved_len; i++) {
-      ICData& icd = ICData::ZoneHandle(zone());
-      icd ^= old_saved_icdata.At(i);
-      (*deopt_id_to_ic_data_)[icd.deopt_id()] = &icd;
+        old_saved_ic_data.IsNull() ? 0 : old_saved_ic_data.Length();
+    for (intptr_t i = 1; i < saved_len; i++) {
+      ICData& ic_data = ICData::ZoneHandle(zone());
+      ic_data ^= old_saved_ic_data.At(i);
+      (*deopt_id_to_ic_data_)[ic_data.deopt_id()] = &ic_data;
     }
   }
   ASSERT(assembler != NULL);
   ASSERT(!list_class_.IsNull());
 }
 
 
 void FlowGraphCompiler::InitCompiler() {
   pc_descriptors_list_ = new(zone()) DescriptorList(64);
   exception_handlers_list_ = new(zone())ExceptionHandlerList();
@@ skipping 34 matching lines @@
           }
         }
       }
     }
   }
   if (is_leaf) {
     // Remove the stack overflow check at function entry.
     Instruction* first = flow_graph_.graph_entry()->normal_entry()->next();
     if (first->IsCheckStackOverflow()) first->RemoveFromGraph();
   }
+  if (!is_optimizing()) {
+    // Initialize edge counter array.
+    const intptr_t num_counters = flow_graph_.preorder().length();
+    const Array& edge_counters =
+        Array::Handle(Array::New(num_counters, Heap::kOld));
+    const Smi& zero_smi = Smi::Handle(Smi::New(0));
+    for (intptr_t i = 0; i < num_counters; ++i) {
+      edge_counters.SetAt(i, zero_smi);
+    }
+    edge_counters_array_ = edge_counters.raw();
+  }
 }
 
 
 bool FlowGraphCompiler::CanOptimize() {
   return FLAG_optimization_counter_threshold >= 0;
 }
 
 
 bool FlowGraphCompiler::CanOptimizeFunction() const {
   return CanOptimize() && !parsed_function().function().HasBreakpoint();
@@ skipping 1544 matching lines @@
 
 
 void FlowGraphCompiler::FrameStateClear() {
   ASSERT(!is_optimizing());
   frame_state_.TruncateTo(0);
 }
 #endif
 
 
 }  // namespace dart