Fix compiler stats

runtime/vm/compiler_stats.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/compiler_stats.h"
 
 #include "vm/flags.h"
 #include "vm/log.h"
 #include "vm/object_graph.h"
 #include "vm/timer.h"
@@ skipping 119 matching lines @@
   use_benchmark_output = true;
 }
 
 
 // Generate output for Golem benchmark harness. If the output format
 // changes, the parsing function in Golem must be updated.
 char* CompilerStats::BenchmarkOutput() {
   Update();
   Log log(PrintToStats);
   LogBlock lb(Thread::Current(), &log);
+  log.Print("==== Compiler Stats for isolate '%s' ====\n",
+            isolate_->debugger_name());
+
   log.Print("NumberOfTokens: %" Pd64 "\n", num_tokens_total);
   log.Print("NumClassesParsed: %" Pd64 "\n", num_classes_parsed);
   log.Print("NumFunctionsCompiled: %" Pd64 "\n", num_functions_compiled);
   log.Print("NumFunctionsOptimized: %" Pd64 "\n", num_functions_optimized);
   log.Print("NumFunctionsParsed: %" Pd64 "\n", num_functions_parsed);
 
   // Scanner stats.
   int64_t scan_usecs = scanner_timer.TotalElapsedTime();
   int64_t scan_speed =
       scan_usecs > 0 ? 1000 * num_tokens_scanned / scan_usecs : 0;
   log.Print("NumTokensScanned: %" Pd64 " tokens\n", num_tokens_scanned);
   log.Print("ScannerTime: %" Pd64 " ms\n", scan_usecs / 1000);
   log.Print("ScannerSpeed: %" Pd64 " tokens/ms\n", scan_speed);
 
   // Parser stats.
   int64_t parse_usecs = parser_timer.TotalElapsedTime();
   int64_t parse_speed =
       parse_usecs > 0 ? 1000 * num_tokens_consumed / parse_usecs : 0;
   log.Print("NumTokensParsed: %" Pd64 " tokens\n", num_tokens_consumed);
   log.Print("ParserTime: %" Pd64 " ms\n", parse_usecs / 1000);
   log.Print("ParserSpeed: %" Pd64 " tokens/ms\n", parse_speed);
 
   // Compiler stats.
   int64_t codegen_usecs = codegen_timer.TotalElapsedTime();
-  int64_t compile_usecs = scan_usecs+ parse_usecs + codegen_usecs;
+  int64_t compile_usecs = scan_usecs + parse_usecs + codegen_usecs;
+  int64_t compile_speed =
+      compile_usecs > 0 ? (1000 * num_func_tokens_compiled / compile_usecs) : 0;
   log.Print("NumTokensCompiled: %" Pd64 " tokens\n", num_func_tokens_compiled);
   log.Print("CompilerTime: %" Pd64 " ms\n", compile_usecs / 1000);
 
-  log.Print("CompilerSpeed: %" Pd64 " tokens/ms\n",
-            compile_usecs > 0 ?
-                (1000 * num_func_tokens_compiled / compile_usecs) : 0);
+  log.Print("CompilerSpeed: %" Pd64 " tokens/ms\n", compile_speed);
   log.Print("CodeSize: %" Pd64 " KB\n", total_code_size / 1024);
-  log.Print("CodeDensity: %" Pd64 " tokens/KB\n",
-            (1024 * num_func_tokens_compiled) / total_instr_size);
+  int64_t code_density = total_instr_size > 0 ?
+      (num_func_tokens_compiled * 1024) / total_instr_size : 0;
+
+  log.Print("CodeDensity: %" Pd64 " tokens/KB\n", code_density);
   log.Print("InstrSize: %" Pd64 " KB\n", total_instr_size / 1024);
   log.Flush();
   char* benchmark_text = text;
   text = NULL;
   return benchmark_text;
 }
 
 
 char* CompilerStats::PrintToZone() {
   if (!FLAG_compiler_stats) {
@@ skipping 34 matching lines @@
   int64_t parse_usecs = parser_timer.TotalElapsedTime();
   int64_t parse_speed =
       parse_usecs > 0 ? 1000 * num_tokens_consumed / parse_usecs : 0;
   log.Print("Parser time:             %" Pd64 " ms\n", parse_usecs / 1000);
   log.Print("Parser speed:            %" Pd64 " tokens/ms\n",
              parse_speed);
 
   int64_t codegen_usecs = codegen_timer.TotalElapsedTime();
 
   log.Print("==== Backend stats:\n");
-  log.Print("Code gen. time:          %" Pd64 " ms\n",
-            codegen_usecs / 1000);
+  log.Print("Code gen. time:          %" Pd64 " ms\n", codegen_usecs / 1000);
   int64_t graphbuilder_usecs = graphbuilder_timer.TotalElapsedTime();
   log.Print("  Graph builder:         %" Pd64 " ms\n",
             graphbuilder_usecs / 1000);
   int64_t ssa_usecs = ssa_timer.TotalElapsedTime();
   log.Print("  Graph SSA:             %" Pd64 " ms\n", ssa_usecs / 1000);
 
   int64_t graphinliner_usecs = graphinliner_timer.TotalElapsedTime();
   log.Print("  Graph inliner:         %" Pd64 " ms\n",
             graphinliner_usecs / 1000);
   int64_t graphinliner_parse_usecs =
@@ skipping 19 matching lines @@
             (graphoptimizer_usecs - graphinliner_usecs) / 1000);
   int64_t graphcompiler_usecs = graphcompiler_timer.TotalElapsedTime();
   log.Print("  Graph compiler:        %" Pd64 " ms\n",
             graphcompiler_usecs / 1000);
   int64_t codefinalizer_usecs = codefinalizer_timer.TotalElapsedTime();
   log.Print("  Code finalizer:        %" Pd64 " ms\n",
             codefinalizer_usecs / 1000);
 
   log.Print("==== Compiled code stats:\n");
   int64_t compile_usecs = scan_usecs + parse_usecs + codegen_usecs;
+  int64_t compile_speed = compile_usecs > 0 ?
+      (1000 * num_func_tokens_compiled / compile_usecs) : 0;
   log.Print("Functions parsed:        %" Pd64 "\n", num_functions_parsed);
   log.Print("Functions compiled:      %" Pd64 "\n", num_functions_compiled);
   log.Print("  optimized:             %" Pd64 "\n", num_functions_optimized);
   log.Print("Compiler time:           %" Pd64 " ms\n", compile_usecs / 1000);
   log.Print("Tokens compiled:         %" Pd64 "\n", num_func_tokens_compiled);
-  log.Print("Compilation speed:       %" Pd64 " tokens/ms\n",
-            (1000 * num_func_tokens_compiled) / compile_usecs);
-  log.Print("Code density:            %" Pd64 " tokens per KB\n",
-            (num_func_tokens_compiled * 1024) / total_instr_size);
+  log.Print("Compilation speed:       %" Pd64 " tokens/ms\n", compile_speed);
+  int64_t code_density = total_instr_size > 0 ?
+      (num_func_tokens_compiled * 1024) / total_instr_size : 0;
+  log.Print("Code density:            %" Pd64 " tokens per KB\n", code_density);
   log.Print("Code size:               %" Pd64 " KB\n", total_code_size / 1024);
   log.Print("  Instr size:            %" Pd64 " KB\n",
             total_instr_size / 1024);
   log.Print("  Pc Desc size:          %" Pd64 " KB\n", pc_desc_size / 1024);
   log.Print("  VarDesc size:          %" Pd64 " KB\n", vardesc_size / 1024);
   log.Flush();
   char* stats_text = text;
   text = NULL;
   return stats_text;
 }
 
 }  // namespace dart