sdk/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/object_graph.h"
#include "vm/timer.h"


namespace dart {

DEFINE_FLAG(bool, compiler_stats, false, "Compiler stat counters.");


class TokenStreamVisitor : public ObjectGraph::Visitor {
 public:
  explicit TokenStreamVisitor(CompilerStats* compiler_stats)
      : obj_(Object::Handle()), stats_(compiler_stats) {
  }

  virtual Direction VisitObject(ObjectGraph::StackIterator* it) {
    RawObject* raw_obj = it->Get();
    if (raw_obj->IsFreeListElement()) {
      return kProceed;
    }
    obj_ = raw_obj;
    if (obj_.GetClassId() == TokenStream::kClassId) {
      TokenStream::Iterator tkit(TokenStream::Cast(obj_),
                                 0,
                                 TokenStream::Iterator::kNoNewlines);
      Token::Kind kind = tkit.CurrentTokenKind();
      while (kind != Token::kEOS) {
        ++stats_->num_tokens_total;
        if (kind == Token::kIDENT) {
          ++stats_->num_ident_tokens_total;
        } else if (Token::NeedsLiteralToken(kind)) {
          ++stats_->num_literal_tokens_total;
        }
        tkit.Advance();
        kind = tkit.CurrentTokenKind();
      }
    }
    return kProceed;
  }

 private:
  Object& obj_;
  CompilerStats* stats_;
};


CompilerStats::CompilerStats(Isolate* isolate)
    : isolate_(isolate),
      parser_timer(true, "parser timer"),
      scanner_timer(true, "scanner timer"),
      codegen_timer(true, "codegen timer"),
      graphbuilder_timer(true, "flow graph builder timer"),
      ssa_timer(true, "flow graph SSA timer"),
      graphinliner_timer(true, "flow graph inliner timer"),
      graphinliner_parse_timer(true, "inliner parsing timer"),
      graphinliner_build_timer(true, "inliner building timer"),
      graphinliner_ssa_timer(true, "inliner SSA timer"),
      graphinliner_opt_timer(true, "inliner optimization timer"),
      graphinliner_subst_timer(true, "inliner substitution timer"),
      graphoptimizer_timer(true, "flow graph optimizer timer"),
      graphcompiler_timer(true, "flow graph compiler timer"),
      codefinalizer_timer(true, "code finalization timer"),
      num_tokens_total(0),
      num_literal_tokens_total(0),
      num_ident_tokens_total(0),
      num_tokens_consumed(0),
      num_token_checks(0),
      num_tokens_lookahead(0),
      num_classes_compiled(0),
      num_functions_compiled(0),
      num_implicit_final_getters(0),
      src_length(0),
      total_code_size(0),
      total_instr_size(0),
      pc_desc_size(0),
      vardesc_size(0) {
}


void CompilerStats::Print() {
  if (!FLAG_compiler_stats) {
    return;
  }

  // Traverse the heap and compute number of tokens in all
  // TokenStream objects.
  num_tokens_total = 0;
  num_literal_tokens_total = 0;
  num_ident_tokens_total = 0;
  TokenStreamVisitor visitor(this);
  ObjectGraph graph(isolate_);
  graph.IterateObjects(&visitor);

  OS::Print("==== Compiler Stats for isolate '%s' ====\n",
            isolate_->debugger_name());
  OS::Print("Number of tokens:   %" Pd64 "\n", num_tokens_total);
  OS::Print("  Literal tokens:   %" Pd64 "\n", num_literal_tokens_total);
  OS::Print("  Ident tokens:     %" Pd64 "\n", num_ident_tokens_total);
  OS::Print("Tokens consumed:    %" Pd64 " (%.2f times number of tokens)\n",
            num_tokens_consumed,
            (1.0 * num_tokens_consumed) / num_tokens_total);
  OS::Print("Tokens checked:     %" Pd64 "  (%.2f times tokens consumed)\n",
            num_token_checks, (1.0 * num_token_checks) / num_tokens_consumed);
  OS::Print("Token lookahead:    %" Pd64 " (%" Pd64 "%% of tokens checked)\n",
            num_tokens_lookahead,
            (100 * num_tokens_lookahead) / num_token_checks);

  OS::Print("Classes parsed:     %" Pd64 "\n", num_classes_compiled);
  OS::Print("Functions compiled: %" Pd64 "\n", num_functions_compiled);
  OS::Print("  Impl getters:     %" Pd64 "\n", num_implicit_final_getters);

  OS::Print("Source length:      %" Pd64 " characters\n", src_length);
  int64_t scan_usecs = scanner_timer.TotalElapsedTime();
  OS::Print("Scanner time:       %" Pd64 " msecs\n",
            scan_usecs / 1000);
  int64_t parse_usecs = parser_timer.TotalElapsedTime();
  OS::Print("Parser time:        %" Pd64 " msecs\n",
            parse_usecs / 1000);
  int64_t codegen_usecs = codegen_timer.TotalElapsedTime();
  OS::Print("Code gen. time:     %" Pd64 " msecs\n",
            codegen_usecs / 1000);
  int64_t graphbuilder_usecs = graphbuilder_timer.TotalElapsedTime();
  OS::Print("  Graph builder:    %" Pd64 " msecs\n", graphbuilder_usecs / 1000);
  int64_t ssa_usecs = ssa_timer.TotalElapsedTime();
  OS::Print("  Graph SSA:        %" Pd64 " msecs\n", ssa_usecs / 1000);

  int64_t graphinliner_usecs = graphinliner_timer.TotalElapsedTime();
  OS::Print("  Graph inliner:    %" Pd64 " msecs\n", graphinliner_usecs / 1000);
  int64_t graphinliner_parse_usecs =
      graphinliner_parse_timer.TotalElapsedTime();
  OS::Print("    Parsing:        %" Pd64 " msecs\n",
            graphinliner_parse_usecs / 1000);
  int64_t graphinliner_build_usecs =
      graphinliner_build_timer.TotalElapsedTime();
  OS::Print("    Building:       %" Pd64 " msecs\n",
            graphinliner_build_usecs / 1000);
  int64_t graphinliner_ssa_usecs = graphinliner_ssa_timer.TotalElapsedTime();
  OS::Print("    SSA:            %" Pd64 " msecs\n",
            graphinliner_ssa_usecs / 1000);
  int64_t graphinliner_opt_usecs = graphinliner_opt_timer.TotalElapsedTime();
  OS::Print("    Optimization:   %" Pd64 " msecs\n",
            graphinliner_opt_usecs / 1000);
  int64_t graphinliner_subst_usecs =
      graphinliner_subst_timer.TotalElapsedTime();
  OS::Print("    Substitution:   %" Pd64 " msecs\n",
            graphinliner_subst_usecs / 1000);

  int64_t graphoptimizer_usecs = graphoptimizer_timer.TotalElapsedTime();
  OS::Print("  Graph optimizer:  %" Pd64 " msecs\n",
            (graphoptimizer_usecs - graphinliner_usecs) / 1000);
  int64_t graphcompiler_usecs = graphcompiler_timer.TotalElapsedTime();
  OS::Print("  Graph compiler:   %" Pd64 " msecs\n",
            graphcompiler_usecs / 1000);
  int64_t codefinalizer_usecs = codefinalizer_timer.TotalElapsedTime();
  OS::Print("  Code finalizer:   %" Pd64 " msecs\n",
            codefinalizer_usecs / 1000);
  OS::Print("Compilation speed:  %" Pd64 " tokens per msec\n",
            (1000 * num_tokens_total) / (parse_usecs + codegen_usecs));
  OS::Print("Code density:       %" Pd64 " tokens per KB\n",
            (num_tokens_total * 1024) / total_instr_size);
  OS::Print("Instr size:         %" Pd64 " KB\n",
            total_instr_size / 1024);
  OS::Print("Pc Desc size:       %" Pd64 " KB\n", pc_desc_size / 1024);
  OS::Print("VarDesc size:       %" Pd64 " KB\n", vardesc_size / 1024);

  OS::Print("Code size:          %" Pd64 " KB\n", total_code_size / 1024);
}

}  // namespace dart