Collect edge count profiling data and reorder basic blocks.

runtime/vm/flow_graph_builder.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/flow_graph_builder.h"
 
 #include "lib/invocation_mirror.h"
 #include "vm/ast_printer.h"
 #include "vm/bit_vector.h"
 #include "vm/code_descriptors.h"
@@ skipping 64 matching lines @@
   ASSERT(callee_graph->max_block_id() > caller_graph_->max_block_id());
   ASSERT(callee_graph->max_virtual_register_number() >
          caller_graph_->max_virtual_register_number());
 
   // Adjust the caller's maximum block id and current SSA temp index.
   caller_graph_->set_max_block_id(callee_graph->max_block_id());
   caller_graph_->set_current_ssa_temp_index(
       callee_graph->max_virtual_register_number());
 
   // Attach the outer environment on each instruction in the callee graph.
+  // Scale the edge weights by the call count for the inlined function.
+  double scale_factor = static_cast<double>(call_->CallCount())
+      / static_cast<double>(caller_graph_->graph_entry()->entry_count());
   for (BlockIterator block_it = callee_graph->postorder_iterator();
        !block_it.Done();
        block_it.Advance()) {
-    for (ForwardInstructionIterator it(block_it.Current());
-         !it.Done();
-         it.Advance()) {
-      Instruction* instr = it.Current();
+    BlockEntryInstr* block = block_it.Current();
+    if (block->IsTargetEntry()) {
+      block->AsTargetEntry()->adjust_edge_weight(scale_factor);
+    }
+    Instruction* instr = block;
+    for (ForwardInstructionIterator it(block); !it.Done(); it.Advance()) {
+      instr = it.Current();
       // TODO(zerny): Avoid creating unnecessary environments. Note that some
       // optimizations need deoptimization info for non-deoptable instructions,
       // eg, LICM on GOTOs.
       if (instr->env() != NULL) call_->env()->DeepCopyToOuter(instr);
     }
+    if (instr->IsGoto()) {
+      instr->AsGoto()->adjust_edge_weight(scale_factor);
+    }
   }
 }
 
 
 void InlineExitCollector::AddExit(ReturnInstr* exit) {
   Data data = { NULL, exit };
   exits_.Add(data);
 }
 
 
@@ skipping 3409 matching lines @@
   }
 
   FlowGraph* graph = new FlowGraph(*this, graph_entry_, last_used_block_id_);
   return graph;
 }
 
 
 void FlowGraphBuilder::PruneUnreachable() {
   ASSERT(osr_id_ != Isolate::kNoDeoptId);
   BitVector* block_marks = new BitVector(last_used_block_id_ + 1);
-  bool found = graph_entry_->PruneUnreachable(this, graph_entry_, osr_id_,
+  bool found = graph_entry_->PruneUnreachable(this, graph_entry_, NULL, osr_id_,

[srdjan, 2013/08/14 00:28:24]

Document what NULL means, e.g., const xxxx pkParent = NULL;

                                               block_marks);
   ASSERT(found);
 }
 
 
 void FlowGraphBuilder::Bailout(const char* reason) {
   const char* kFormat = "FlowGraphBuilder Bailout: %s %s";
   const char* function_name = parsed_function_->function().ToCString();
   intptr_t len = OS::SNPrint(NULL, 0, kFormat, function_name, reason) + 1;
   char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, kFormat, function_name, reason);
   const Error& error = Error::Handle(
       LanguageError::New(String::Handle(String::New(chars))));
   Isolate::Current()->long_jump_base()->Jump(1, error);
 }
 
 
 }  // namespace dart