Add more detailed timers of the various compilation passes. The

aggregate compilation time timer is the same as it was before.

Review URL: http://codereview.chromium.org/115344

git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@1946 ce2b1a6d-e550-0410-aec6-3dcde31c8c00

diff --git a/src/codegen.cc b/src/codegen.cc
index 40c2583..c4c15a8 100644 (file)
--- a/src/codegen.cc
+++ b/src/codegen.cc
@@ -161,7 +161,9 @@ Handle<Code> CodeGenerator::MakeCode(FunctionLiteral* flit,
     return Handle<Code>::null();
   }
 
-  // Allocate and install the code.
+  // Allocate and install the code.  Time the rest of this function as
+  // code creation.
+  HistogramTimerScope timer(&Counters::code_creation);
   CodeDesc desc;
   cgen.masm()->GetCode(&desc);
   ScopeInfo<> sinfo(flit->scope());

diff --git a/src/compiler.cc b/src/compiler.cc
index b947cbb..8143382 100644 (file)
--- a/src/compiler.cc
+++ b/src/compiler.cc
@@ -52,12 +52,15 @@ static Handle<Code> MakeCode(FunctionLiteral* literal,
     return Handle<Code>::null();
   }
 
-  // Compute top scope and allocate variables. For lazy compilation
-  // the top scope only contains the single lazily compiled function,
-  // so this doesn't re-allocate variables repeatedly.
-  Scope* top = literal->scope();
-  while (top->outer_scope() != NULL) top = top->outer_scope();
-  top->AllocateVariables(context);
+  {
+    // Compute top scope and allocate variables. For lazy compilation
+    // the top scope only contains the single lazily compiled function,
+    // so this doesn't re-allocate variables repeatedly.
+    HistogramTimerScope timer(&Counters::variable_allocation);
+    Scope* top = literal->scope();
+    while (top->outer_scope() != NULL) top = top->outer_scope();
+    top->AllocateVariables(context);
+  }
 
 #ifdef DEBUG
   if (Bootstrapper::IsActive() ?

diff --git a/src/ia32/codegen-ia32.cc b/src/ia32/codegen-ia32.cc
index 41751d8..8d54aed 100644 (file)
--- a/src/ia32/codegen-ia32.cc
+++ b/src/ia32/codegen-ia32.cc
@@ -116,6 +116,7 @@ void CodeGenerator::GenCode(FunctionLiteral* fun) {
   JumpTarget::set_compiling_deferred_code(false);
 
   {
+    HistogramTimerScope codegen_timer(&Counters::code_generation);
     CodeGenState state(this);
 
     // Entry:
@@ -318,6 +319,7 @@ void CodeGenerator::GenCode(FunctionLiteral* fun) {
   if (HasStackOverflow()) {
     ClearDeferred();
   } else {
+    HistogramTimerScope deferred_timer(&Counters::deferred_code_generation);
     JumpTarget::set_compiling_deferred_code(true);
     ProcessDeferred();
     JumpTarget::set_compiling_deferred_code(false);

diff --git a/src/rewriter.cc b/src/rewriter.cc
index 4e3676b..983792d 100644 (file)
--- a/src/rewriter.cc
+++ b/src/rewriter.cc
@@ -803,6 +803,7 @@ void Processor::VisitThisFunction(ThisFunction* node) {
 
 
 bool Rewriter::Process(FunctionLiteral* function) {
+  HistogramTimerScope timer(&Counters::rewriting);
   Scope* scope = function->scope();
   if (scope->is_function_scope()) return true;
 
@@ -823,6 +824,7 @@ bool Rewriter::Optimize(FunctionLiteral* function) {
   ZoneList<Statement*>* body = function->body();
 
   if (FLAG_optimize_ast && !body->is_empty()) {
+    HistogramTimerScope timer(&Counters::ast_optimization);
     AstOptimizer optimizer(function->name());
     optimizer.Optimize(body);
     if (optimizer.HasStackOverflow()) {

diff --git a/src/usage-analyzer.cc b/src/usage-analyzer.cc
index 13176f7..b7a1934 100644 (file)
--- a/src/usage-analyzer.cc
+++ b/src/usage-analyzer.cc
@@ -444,6 +444,7 @@ WeightScaler::~WeightScaler() {
 
 bool AnalyzeVariableUsage(FunctionLiteral* lit) {
   if (!FLAG_usage_computation) return true;
+  HistogramTimerScope timer(&Counters::usage_analysis);
   return UsageComputer::Traverse(lit);
 }
 

diff --git a/src/v8-counters.h b/src/v8-counters.h
index d1a6bdf..589b887 100644 (file)
--- a/src/v8-counters.h
+++ b/src/v8-counters.h
@@ -32,16 +32,27 @@
 
 namespace v8 { namespace internal {
 
-#define HISTOGRAM_TIMER_LIST(HT)                                 \
-  HT(gc_compactor, V8.GCCompactor) /* GC Compactor time */       \
-  HT(gc_scavenger, V8.GCScavenger) /* GC Scavenger time */       \
-  HT(gc_context, V8.GCContext)     /* GC context cleanup time */ \
-  HT(compile, V8.Compile)          /* Compile time*/             \
-  HT(compile_eval, V8.CompileEval) /* Eval compile time */       \
-  HT(compile_lazy, V8.CompileLazy) /* Lazy compile time */       \
-  HT(parse, V8.Parse)              /* Parse time */              \
-  HT(parse_lazy, V8.ParseLazy)     /* Lazy parse time */         \
-  HT(pre_parse, V8.PreParse)       /* Pre-parse time */
+#define HISTOGRAM_TIMER_LIST(HT)                                      \
+  /* Garbage collection timers. */                                    \
+  HT(gc_compactor, V8.GCCompactor)                                    \
+  HT(gc_scavenger, V8.GCScavenger)                                    \
+  HT(gc_context, V8.GCContext) /* GC context cleanup time */          \
+  /* Parsing timers. */                                               \
+  HT(parse, V8.Parse)                                                 \
+  HT(parse_lazy, V8.ParseLazy)                                        \
+  HT(pre_parse, V8.PreParse)                                          \
+  /* Total compilation times. */                                      \
+  HT(compile, V8.Compile)                                             \
+  HT(compile_eval, V8.CompileEval)                                    \
+  HT(compile_lazy, V8.CompileLazy)                                    \
+  /* Individual compiler passes. */                                   \
+  HT(rewriting, V8.Rewriting)                                         \
+  HT(usage_analysis, V8.UsageAnalysis)                                \
+  HT(variable_allocation, V8.VariableAllocation)                      \
+  HT(ast_optimization, V8.ASTOptimization)                            \
+  HT(code_generation, V8.CodeGeneration)                              \
+  HT(deferred_code_generation, V8.DeferredCodeGeneration)             \
+  HT(code_creation, V8.CodeCreation)
 
 // WARNING: STATS_COUNTER_LIST_* is a very large macro that is causing MSVC
 // Intellisense to crash.  It was broken into two macros (each of length 40