[turbofan] add absolute peak to stats

src/compiler/pipeline.cc

 // Copyright 2014 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/compiler/pipeline.h"
 
 #include <fstream>  // NOLINT(readability/streams)
 #include <sstream>
 
 #include "src/base/platform/elapsed-timer.h"
@@ skipping 139 matching lines @@
       // TODO(turbofan): Make OSR work and remove this bailout.
       info()->is_osr()) {
     return Handle<Code>::null();
   }
 
   ZonePool zone_pool(isolate());
 
   SmartPointer<PipelineStatistics> pipeline_statistics;
   if (FLAG_turbo_stats) {
     pipeline_statistics.Reset(new PipelineStatistics(info(), &zone_pool));
-    pipeline_statistics->BeginPhaseKind("create graph");
+    pipeline_statistics->BeginPhaseKind("graph creation");
   }
 
   if (FLAG_trace_turbo) {
     OFStream os(stdout);
     os << "---------------------------------------------------\n"
        << "Begin compiling method "
        << info()->function()->debug_name()->ToCString().get()
        << " using Turbofan" << std::endl;
     TurboCfgFile tcf(isolate());
     tcf << AsC1VCompilation(info());
@@ skipping 148 matching lines @@
     JSGenericLowering lowering(info(), &jsgraph);
     GraphReducer graph_reducer(&graph);
     graph_reducer.AddReducer(&lowering);
     graph_reducer.ReduceGraph();
 
     // TODO(jarin, rossberg): Remove UNTYPED once machine typing works.
     VerifyAndPrintGraph(&graph, "Lowered generic", true);
   }
 
   if (!pipeline_statistics.is_empty()) {
-    pipeline_statistics->BeginPhaseKind("code generation");
+    pipeline_statistics->BeginPhaseKind("block building");
   }
 
   source_positions.RemoveDecorator();
 
   Schedule* schedule;
   {
     PhaseScope phase_scope(pipeline_statistics.get(), "scheduling");
     // Compute a schedule.
     schedule = ComputeSchedule(&zone_pool, &graph);
   }
@@ skipping 83 matching lines @@
   }
 
   if (FLAG_trace_turbo) {
     OFStream os(stdout);
     os << "----- Instruction sequence before register allocation -----\n"
        << sequence;
     TurboCfgFile tcf(isolate());
     tcf << AsC1V("CodeGen", schedule, source_positions, &sequence);
   }
 
+  if (pipeline_statistics != NULL) {
+    pipeline_statistics->BeginPhaseKind("register allocation");
+  }
+
   // Allocate registers.
   Frame frame;
   {
     int node_count = graph->NodeCount();
     if (node_count > UnallocatedOperand::kMaxVirtualRegisters) {
       linkage->info()->AbortOptimization(kNotEnoughVirtualRegistersForValues);
       return Handle<Code>::null();
     }
     ZonePool::Scope zone_scope(zone_pool);
     RegisterAllocator allocator(zone_scope.zone(), &frame, linkage->info(),
                                 &sequence);
     if (!allocator.Allocate(pipeline_statistics)) {
       linkage->info()->AbortOptimization(kNotEnoughVirtualRegistersRegalloc);
       return Handle<Code>::null();
     }
     if (FLAG_trace_turbo) {
       TurboCfgFile tcf(isolate());
       tcf << AsC1VAllocator("CodeGen", &allocator);
     }
   }
 
   if (FLAG_trace_turbo) {
     OFStream os(stdout);
     os << "----- Instruction sequence after register allocation -----\n"
        << sequence;
   }
 
+  if (pipeline_statistics != NULL) {
+    pipeline_statistics->BeginPhaseKind("code generation");
+  }
+
   // Generate native sequence.
   Handle<Code> code;
   {
     PhaseScope phase_scope(pipeline_statistics, "generate code");
     CodeGenerator generator(&frame, linkage, &sequence);
     code = generator.GenerateCode();
   }
   if (profiler_data != NULL) {
 #if ENABLE_DISASSEMBLER
     std::ostringstream os;
@@ skipping 10 matching lines @@
 }
 
 
 void Pipeline::TearDown() {
   InstructionOperand::TearDownCaches();
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8