Revision: 24830
Author: [email protected]
Date: Thu Oct 23 09:14:35 2014 UTC
Log: [turbofan] split compilation stats off from HStatistics and track
high water marks
[email protected]
BUG=
Review URL: https://codereview.chromium.org/669053002
https://code.google.com/p/v8/source/detail?r=24830
Added:
/branches/bleeding_edge/src/compilation-statistics.cc
/branches/bleeding_edge/src/compilation-statistics.h
/branches/bleeding_edge/src/compiler/pipeline-statistics.cc
/branches/bleeding_edge/src/compiler/pipeline-statistics.h
Modified:
/branches/bleeding_edge/BUILD.gn
/branches/bleeding_edge/src/compiler/pipeline.cc
/branches/bleeding_edge/src/compiler/pipeline.h
/branches/bleeding_edge/src/compiler/register-allocator.cc
/branches/bleeding_edge/src/compiler/register-allocator.h
/branches/bleeding_edge/src/compiler/zone-pool.cc
/branches/bleeding_edge/src/compiler/zone-pool.h
/branches/bleeding_edge/src/hydrogen.cc
/branches/bleeding_edge/src/hydrogen.h
/branches/bleeding_edge/src/isolate.cc
/branches/bleeding_edge/src/isolate.h
/branches/bleeding_edge/test/unittests/compiler/zone-pool-unittest.cc
/branches/bleeding_edge/tools/gyp/v8.gyp
=======================================
--- /dev/null
+++ /branches/bleeding_edge/src/compilation-statistics.cc Thu Oct 23
09:14:35 2014 UTC
@@ -0,0 +1,140 @@
+// 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 <iostream> // NOLINT(readability/streams)
+#include <vector>
+
+#include "src/base/platform/platform.h"
+#include "src/compilation-statistics.h"
+
+namespace v8 {
+namespace internal {
+
+void CompilationStatistics::RecordPhaseStats(const char* phase_kind_name,
+ const char* phase_name,
+ const BasicStats& stats) {
+ std::string phase_name_str(phase_name);
+ auto it = phase_map_.find(phase_name_str);
+ if (it == phase_map_.end()) {
+ PhaseStats phase_stats(phase_map_.size(), phase_kind_name);
+ it = phase_map_.insert(std::make_pair(phase_name_str,
phase_stats)).first;
+ }
+ it->second.Accumulate(stats);
+}
+
+
+void CompilationStatistics::RecordPhaseKindStats(const char*
phase_kind_name,
+ const BasicStats& stats) {
+ std::string phase_kind_name_str(phase_kind_name);
+ auto it = phase_kind_map_.find(phase_kind_name_str);
+ if (it == phase_kind_map_.end()) {
+ PhaseKindStats phase_kind_stats(phase_kind_map_.size());
+ it = phase_kind_map_.insert(std::make_pair(phase_kind_name_str,
+ phase_kind_stats)).first;
+ }
+ it->second.Accumulate(stats);
+}
+
+
+void CompilationStatistics::RecordTotalStats(size_t source_size,
+ const BasicStats& stats) {
+ source_size += source_size;
+ total_stats_.Accumulate(stats);
+}
+
+
+void CompilationStatistics::BasicStats::Accumulate(const BasicStats&
stats) {
+ delta_ += stats.delta_;
+ total_allocated_bytes_ += stats.total_allocated_bytes_;
+ if (stats.max_allocated_bytes_ > max_allocated_bytes_) {
+ max_allocated_bytes_ = stats.max_allocated_bytes_;
+ function_name_ = stats.function_name_;
+ }
+}
+
+
+static void WriteLine(std::ostream& os, const char* name,
+ const CompilationStatistics::BasicStats& stats,
+ const CompilationStatistics::BasicStats&
total_stats) {
+ const size_t kBufferSize = 128;
+ char buffer[kBufferSize];
+
+ double ms = stats.delta_.InMillisecondsF();
+ double percent = stats.delta_.PercentOf(total_stats.delta_);
+ double size_percent =
+ static_cast<double>(stats.total_allocated_bytes_ * 100) /
+ static_cast<double>(total_stats.total_allocated_bytes_);
+ base::OS::SNPrintF(buffer, kBufferSize,
+ "%28s %10.3f ms / %5.1f %% %10u total / %5.1f %% %10u
max",
+ name, ms, percent, stats.total_allocated_bytes_,
+ size_percent, stats.max_allocated_bytes_);
+
+ os << buffer;
+ if (stats.function_name_.size() > 0) {
+ os << " : " << stats.function_name_.c_str();
+ }
+ os << std::endl;
+}
+
+
+static void WriteFullLine(std::ostream& os) {
+ os << "-----------------------------------------------"
+ "-----------------------------------------------\n";
+}
+
+
+static void WriteHeader(std::ostream& os) {
+ WriteFullLine(os);
+ os << " Turbofan timing results:\n";
+ WriteFullLine(os);
+}
+
+
+static void WritePhaseKindBreak(std::ostream& os) {
+ os << " ------------------"
+ "-----------------------------------------------\n";
+}
+
+
+std::ostream& operator<<(std::ostream& os, const CompilationStatistics& s)
{
+ // phase_kind_map_ and phase_map_ don't get mutated, so store a bunch of
+ // pointers into them.
+
+ typedef std::vector<CompilationStatistics::PhaseKindMap::const_iterator>
+ SortedPhaseKinds;
+ SortedPhaseKinds sorted_phase_kinds(s.phase_kind_map_.size());
+ for (auto it = s.phase_kind_map_.begin(); it != s.phase_kind_map_.end();
+ ++it) {
+ sorted_phase_kinds[it->second.insert_order_] = it;
+ }
+
+ typedef std::vector<CompilationStatistics::PhaseMap::const_iterator>
+ SortedPhases;
+ SortedPhases sorted_phases(s.phase_map_.size());
+ for (auto it = s.phase_map_.begin(); it != s.phase_map_.end(); ++it) {
+ sorted_phases[it->second.insert_order_] = it;
+ }
+
+ WriteHeader(os);
+ for (auto phase_kind_it : sorted_phase_kinds) {
+ const auto& phase_kind_name = phase_kind_it->first;
+ for (auto phase_it : sorted_phases) {
+ const auto& phase_stats = phase_it->second;
+ if (phase_stats.phase_kind_name_ != phase_kind_name) continue;
+ const auto& phase_name = phase_it->first;
+ WriteLine(os, phase_name.c_str(), phase_stats, s.total_stats_);
+ }
+ WritePhaseKindBreak(os);
+ const auto& phase_kind_stats = phase_kind_it->second;
+ WriteLine(os, phase_kind_name.c_str(), phase_kind_stats,
s.total_stats_);
+ os << std::endl;
+ }
+ WriteFullLine(os);
+ WriteLine(os, "totals", s.total_stats_, s.total_stats_);
+
+ return os;
+}
+
+} // namespace internal
+} // namespace v8
=======================================
--- /dev/null
+++ /branches/bleeding_edge/src/compilation-statistics.h Thu Oct 23
09:14:35 2014 UTC
@@ -0,0 +1,82 @@
+// 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.
+
+#ifndef V8_COMPILATION_STATISTICS_H_
+#define V8_COMPILATION_STATISTICS_H_
+
+#include <map>
+#include <string>
+
+#include "src/allocation.h"
+#include "src/base/platform/time.h"
+
+namespace v8 {
+namespace internal {
+
+class CompilationInfo;
+
+class CompilationStatistics FINAL : public Malloced {
+ public:
+ CompilationStatistics() {}
+
+ class BasicStats {
+ public:
+ BasicStats() : total_allocated_bytes_(0), max_allocated_bytes_(0) {}
+
+ void Accumulate(const BasicStats& stats);
+
+ base::TimeDelta delta_;
+ size_t total_allocated_bytes_;
+ size_t max_allocated_bytes_;
+ std::string function_name_;
+ };
+
+ void RecordPhaseStats(const char* phase_kind_name, const char*
phase_name,
+ const BasicStats& stats);
+
+ void RecordPhaseKindStats(const char* phase_kind_name,
+ const BasicStats& stats);
+
+ void RecordTotalStats(size_t source_size, const BasicStats& stats);
+
+ private:
+ class TotalStats : public BasicStats {
+ public:
+ TotalStats() : source_size_(0) {}
+ uint64_t source_size_;
+ };
+
+ class OrderedStats : public BasicStats {
+ public:
+ explicit OrderedStats(size_t insert_order) :
insert_order_(insert_order) {}
+ size_t insert_order_;
+ };
+
+ class PhaseStats : public OrderedStats {
+ public:
+ PhaseStats(size_t insert_order, const char* phase_kind_name)
+ : OrderedStats(insert_order), phase_kind_name_(phase_kind_name) {}
+ std::string phase_kind_name_;
+ };
+
+ friend std::ostream& operator<<(std::ostream& os,
+ const CompilationStatistics& s);
+
+ typedef OrderedStats PhaseKindStats;
+ typedef std::map<std::string, PhaseKindStats> PhaseKindMap;
+ typedef std::map<std::string, PhaseStats> PhaseMap;
+
+ TotalStats total_stats_;
+ PhaseKindMap phase_kind_map_;
+ PhaseMap phase_map_;
+
+ DISALLOW_COPY_AND_ASSIGN(CompilationStatistics);
+};
+
+std::ostream& operator<<(std::ostream& os, const CompilationStatistics& s);
+
+} // namespace internal
+} // namespace v8
+
+#endif
=======================================
--- /dev/null
+++ /branches/bleeding_edge/src/compiler/pipeline-statistics.cc Thu Oct 23
09:14:35 2014 UTC
@@ -0,0 +1,97 @@
+// 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.h"
+#include "src/compiler/pipeline-statistics.h"
+#include "src/compiler/zone-pool.h"
+
+namespace v8 {
+namespace internal {
+namespace compiler {
+
+void PipelineStatistics::CommonStats::Begin(
+ PipelineStatistics* pipeline_stats) {
+ DCHECK(scope_.is_empty());
+ scope_.Reset(new ZonePool::StatsScope(pipeline_stats->zone_pool_));
+ timer_.Start();
+ outer_zone_initial_size_ = pipeline_stats->OuterZoneSize();
+}
+
+
+void PipelineStatistics::CommonStats::End(
+ PipelineStatistics* pipeline_stats,
+ CompilationStatistics::BasicStats* diff) {
+ DCHECK(!scope_.is_empty());
+ diff->function_name_ = pipeline_stats->function_name_;
+ diff->delta_ = timer_.Elapsed();
+ size_t outer_zone_diff =
+ pipeline_stats->OuterZoneSize() - outer_zone_initial_size_;
+ diff->max_allocated_bytes_ = outer_zone_diff +
scope_->GetMaxAllocatedBytes();
+ diff->total_allocated_bytes_ =
+ outer_zone_diff + scope_->GetTotalAllocatedBytes();
+ scope_.Reset(NULL);
+ timer_.Stop();
+}
+
+
+PipelineStatistics::PipelineStatistics(CompilationInfo* info,
+ ZonePool* zone_pool)
+ : isolate_(info->zone()->isolate()),
+ outer_zone_(info->zone()),
+ zone_pool_(zone_pool),
+ compilation_stats_(isolate_->GetTurboStatistics()),
+ source_size_(0),
+ phase_kind_name_(NULL),
+ phase_name_(NULL) {
+ if (!info->shared_info().is_null()) {
+ source_size_ = static_cast<size_t>(info->shared_info()->SourceSize());
+ SmartArrayPointer<char> name =
+ info->shared_info()->DebugName()->ToCString();
+ function_name_ = name.get();
+ }
+ total_stats_.Begin(this);
+}
+
+
+PipelineStatistics::~PipelineStatistics() {
+ if (InPhaseKind()) EndPhaseKind();
+ CompilationStatistics::BasicStats diff;
+ total_stats_.End(this, &diff);
+ compilation_stats_->RecordTotalStats(source_size_, diff);
+}
+
+
+void PipelineStatistics::BeginPhaseKind(const char* phase_kind_name) {
+ DCHECK(!InPhase());
+ if (InPhaseKind()) EndPhaseKind();
+ phase_kind_name_ = phase_kind_name;
+ phase_kind_stats_.Begin(this);
+}
+
+
+void PipelineStatistics::EndPhaseKind() {
+ DCHECK(!InPhase());
+ CompilationStatistics::BasicStats diff;
+ phase_kind_stats_.End(this, &diff);
+ compilation_stats_->RecordPhaseKindStats(phase_kind_name_, diff);
+}
+
+
+void PipelineStatistics::BeginPhase(const char* name) {
+ DCHECK(InPhaseKind());
+ phase_name_ = name;
+ phase_stats_.Begin(this);
+}
+
+
+void PipelineStatistics::EndPhase() {
+ DCHECK(InPhaseKind());
+ CompilationStatistics::BasicStats diff;
+ phase_stats_.End(this, &diff);
+ compilation_stats_->RecordPhaseStats(phase_kind_name_, phase_name_,
diff);
+}
+
+} // namespace compiler
+} // namespace internal
+} // namespace v8
=======================================
--- /dev/null
+++ /branches/bleeding_edge/src/compiler/pipeline-statistics.h Thu Oct 23
09:14:35 2014 UTC
@@ -0,0 +1,94 @@
+// 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.
+
+#ifndef V8_COMPILER_PIPELINE_STATISTICS_H_
+#define V8_COMPILER_PIPELINE_STATISTICS_H_
+
+#include <string>
+
+#include "src/compilation-statistics.h"
+#include "src/compiler/zone-pool.h"
+
+namespace v8 {
+namespace internal {
+namespace compiler {
+
+class PhaseScope;
+
+class PipelineStatistics : public Malloced {
+ public:
+ PipelineStatistics(CompilationInfo* info, ZonePool* zone_pool);
+ ~PipelineStatistics();
+
+ void BeginPhaseKind(const char* phase_kind_name);
+
+ private:
+ size_t OuterZoneSize() {
+ return static_cast<size_t>(outer_zone_->allocation_size());
+ }
+
+ class CommonStats {
+ public:
+ CommonStats() : outer_zone_initial_size_(0) {}
+
+ void Begin(PipelineStatistics* pipeline_stats);
+ void End(PipelineStatistics* pipeline_stats,
+ CompilationStatistics::BasicStats* diff);
+
+ SmartPointer<ZonePool::StatsScope> scope_;
+ base::ElapsedTimer timer_;
+ size_t outer_zone_initial_size_;
+ };
+
+ bool InPhaseKind() { return !phase_kind_stats_.scope_.is_empty(); }
+ void EndPhaseKind();
+
+ friend class PhaseScope;
+ bool InPhase() { return !phase_stats_.scope_.is_empty(); }
+ void BeginPhase(const char* name);
+ void EndPhase();
+
+ Isolate* isolate_;
+ Zone* outer_zone_;
+ ZonePool* zone_pool_;
+ CompilationStatistics* compilation_stats_;
+ std::string function_name_;
+
+ // Stats for the entire compilation.
+ CommonStats total_stats_;
+ size_t source_size_;
+
+ // Stats for phase kind.
+ const char* phase_kind_name_;
+ CommonStats phase_kind_stats_;
+
+ // Stats for phase.
+ const char* phase_name_;
+ CommonStats phase_stats_;
+
+ DISALLOW_COPY_AND_ASSIGN(PipelineStatistics);
+};
+
+
+class PhaseScope {
+ public:
+ PhaseScope(PipelineStatistics* pipeline_stats, const char* name)
+ : pipeline_stats_(pipeline_stats) {
+ if (pipeline_stats_ != NULL) pipeline_stats_->BeginPhase(name);
+ }
+ ~PhaseScope() {
+ if (pipeline_stats_ != NULL) pipeline_stats_->EndPhase();
+ }
+
+ private:
+ PipelineStatistics* const pipeline_stats_;
+
+ DISALLOW_COPY_AND_ASSIGN(PhaseScope);
+};
+
+} // namespace compiler
+} // namespace internal
+} // namespace v8
+
+#endif
=======================================
--- /branches/bleeding_edge/BUILD.gn Tue Oct 21 18:16:50 2014 UTC
+++ /branches/bleeding_edge/BUILD.gn Thu Oct 23 09:14:35 2014 UTC
@@ -474,6 +474,8 @@
"src/codegen.h",
"src/compilation-cache.cc",
"src/compilation-cache.h",
+ "src/compilation-statistics.cc",
+ "src/compilation-statistics.h",
"src/compiler/access-builder.cc",
"src/compiler/access-builder.h",
"src/compiler/ast-graph-builder.cc",
@@ -560,6 +562,8 @@
"src/compiler/phi-reducer.h",
"src/compiler/pipeline.cc",
"src/compiler/pipeline.h",
+ "src/compiler/pipeline-statistics.cc",
+ "src/compiler/pipeline-statistics.h",
"src/compiler/raw-machine-assembler.cc",
"src/compiler/raw-machine-assembler.h",
"src/compiler/register-allocator.cc",
=======================================
--- /branches/bleeding_edge/src/compiler/pipeline.cc Thu Oct 23 07:36:39
2014 UTC
+++ /branches/bleeding_edge/src/compiler/pipeline.cc Thu Oct 23 09:14:35
2014 UTC
@@ -2,8 +2,6 @@
// 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 <sstream>
#include "src/base/platform/elapsed-timer.h"
@@ -22,6 +20,8 @@
#include "src/compiler/js-typed-lowering.h"
#include "src/compiler/machine-operator-reducer.h"
#include "src/compiler/phi-reducer.h"
+#include "src/compiler/pipeline.h"
+#include "src/compiler/pipeline-statistics.h"
#include "src/compiler/register-allocator.h"
#include "src/compiler/schedule.h"
#include "src/compiler/scheduler.h"
@@ -31,7 +31,6 @@
#include "src/compiler/value-numbering-reducer.h"
#include "src/compiler/verifier.h"
#include "src/compiler/zone-pool.h"
-#include "src/hydrogen.h"
#include "src/ostreams.h"
#include "src/utils.h"
@@ -39,55 +38,6 @@
namespace internal {
namespace compiler {
-class PhaseStats {
- public:
- enum PhaseKind { CREATE_GRAPH, OPTIMIZATION, CODEGEN };
-
- PhaseStats(CompilationInfo* info, ZonePool* zone_pool, PhaseKind kind,
- const char* name)
- : info_(info),
- stats_scope_(zone_pool),
- kind_(kind),
- name_(name),
- size_(0) {
- if (FLAG_turbo_stats) {
- timer_.Start();
- size_ = info_->zone()->allocation_size();
- }
- }
-
- ~PhaseStats() {
- if (FLAG_turbo_stats) {
- base::TimeDelta delta = timer_.Elapsed();
- size_t bytes = info_->zone()->allocation_size() +
- stats_scope_.GetMaxAllocatedBytes() - size_;
- HStatistics* stats = info_->isolate()->GetTStatistics();
- stats->SaveTiming(name_, delta, static_cast<int>(bytes));
-
- switch (kind_) {
- case CREATE_GRAPH:
- stats->IncrementCreateGraph(delta);
- break;
- case OPTIMIZATION:
- stats->IncrementOptimizeGraph(delta);
- break;
- case CODEGEN:
- stats->IncrementGenerateCode(delta);
- break;
- }
- }
- }
-
- private:
- CompilationInfo* info_;
- ZonePool::StatsScope stats_scope_;
- PhaseKind kind_;
- const char* name_;
- size_t size_;
- base::ElapsedTimer timer_;
-};
-
-
static inline bool VerifyGraphs() {
#ifdef DEBUG
return true;
@@ -226,7 +176,13 @@
return Handle<Code>::null();
}
- if (FLAG_turbo_stats) isolate()->GetTStatistics()->Initialize(info_);
+ 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");
+ }
if (FLAG_trace_turbo) {
OFStream os(stdout);
@@ -236,8 +192,6 @@
<< " using Turbofan" << std::endl;
PrintCompilationStart();
}
-
- ZonePool zone_pool(isolate());
// Build the graph.
Graph graph(zone());
@@ -253,8 +207,7 @@
JSGraph jsgraph(&graph, &common, &javascript, &machine);
Node* context_node;
{
- PhaseStats graph_builder_stats(info(), &zone_pool,
PhaseStats::CREATE_GRAPH,
- "graph builder");
+ PhaseScope phase_scope(pipeline_statistics.get(), "graph builder");
ZonePool::Scope zone_scope(&zone_pool);
AstGraphBuilderWithPositions graph_builder(zone_scope.zone(), info(),
&jsgraph,
&source_positions);
@@ -262,8 +215,7 @@
context_node = graph_builder.GetFunctionContext();
}
{
- PhaseStats phi_reducer_stats(info(), &zone_pool,
PhaseStats::CREATE_GRAPH,
- "phi reduction");
+ PhaseScope phase_scope(pipeline_statistics.get(), "phi reduction");
PhiReducer phi_reducer;
GraphReducer graph_reducer(&graph);
graph_reducer.AddReducer(&phi_reducer);
@@ -285,6 +237,7 @@
}
if (info()->is_inlining_enabled()) {
+ PhaseScope phase_scope(pipeline_statistics.get(), "inlining");
SourcePositionTable::Scope pos(&source_positions,
SourcePosition::Unknown());
ZonePool::Scope zone_scope(&zone_pool);
@@ -304,15 +257,20 @@
if (info()->is_typing_enabled()) {
{
// Type the graph.
- PhaseStats typer_stats(info(), &zone_pool, PhaseStats::CREATE_GRAPH,
- "typer");
+ PhaseScope phase_scope(pipeline_statistics.get(), "typer");
typer.Run();
VerifyAndPrintGraph(&graph, "Typed");
}
+ }
+
+ if (!pipeline_statistics.is_empty()) {
+ pipeline_statistics->BeginPhaseKind("lowering");
+ }
+
+ if (info()->is_typing_enabled()) {
{
// Lower JSOperators where we can determine types.
- PhaseStats lowering_stats(info(), &zone_pool,
PhaseStats::CREATE_GRAPH,
- "typed lowering");
+ PhaseScope phase_scope(pipeline_statistics.get(), "typed lowering");
SourcePositionTable::Scope pos(&source_positions,
SourcePosition::Unknown());
ValueNumberingReducer vn_reducer(zone());
@@ -328,8 +286,7 @@
}
{
// Lower simplified operators and insert changes.
- PhaseStats lowering_stats(info(), &zone_pool,
PhaseStats::CREATE_GRAPH,
- "simplified lowering");
+ PhaseScope phase_scope(pipeline_statistics.get(), "simplified
lowering");
SourcePositionTable::Scope pos(&source_positions,
SourcePosition::Unknown());
SimplifiedLowering lowering(&jsgraph);
@@ -345,8 +302,7 @@
}
{
// Lower changes that have been inserted before.
- PhaseStats lowering_stats(info(), &zone_pool,
PhaseStats::OPTIMIZATION,
- "change lowering");
+ PhaseScope phase_scope(pipeline_statistics.get(), "change lowering");
SourcePositionTable::Scope pos(&source_positions,
SourcePosition::Unknown());
Linkage linkage(info());
@@ -367,10 +323,9 @@
}
{
+ PhaseScope phase_scope(pipeline_statistics.get(), "control
reduction");
SourcePositionTable::Scope pos(&source_positions,
SourcePosition::Unknown());
- PhaseStats control_reducer_stats(
- info(), &zone_pool, PhaseStats::CREATE_GRAPH, "control
reduction");
ZonePool::Scope zone_scope(&zone_pool);
ControlReducer::ReduceGraph(zone_scope.zone(), &jsgraph, &common);
@@ -380,8 +335,7 @@
{
// Lower any remaining generic JSOperators.
- PhaseStats lowering_stats(info(), &zone_pool, PhaseStats::CREATE_GRAPH,
- "generic lowering");
+ PhaseScope phase_scope(pipeline_statistics.get(), "generic lowering");
SourcePositionTable::Scope pos(&source_positions,
SourcePosition::Unknown());
JSGenericLowering lowering(info(), &jsgraph);
@@ -392,19 +346,26 @@
// TODO(jarin, rossberg): Remove UNTYPED once machine typing works.
VerifyAndPrintGraph(&graph, "Lowered generic", true);
}
+
+ if (!pipeline_statistics.is_empty()) {
+ pipeline_statistics->BeginPhaseKind("code generation");
+ }
source_positions.RemoveDecorator();
+
+ Schedule* schedule;
+ {
+ PhaseScope phase_scope(pipeline_statistics.get(), "scheduling");
+ // Compute a schedule.
+ schedule = ComputeSchedule(&zone_pool, &graph);
+ }
Handle<Code> code = Handle<Code>::null();
{
- // Compute a schedule.
- Schedule* schedule = ComputeSchedule(&zone_pool, &graph);
// Generate optimized code.
- PhaseStats codegen_stats(info(), &zone_pool, PhaseStats::CODEGEN,
- "codegen");
Linkage linkage(info());
- code =
- GenerateCode(&zone_pool, &linkage, &graph, schedule,
&source_positions);
+ code = GenerateCode(pipeline_statistics.get(), &zone_pool, &linkage,
&graph,
+ schedule, &source_positions);
info()->SetCode(code);
}
@@ -424,8 +385,6 @@
Schedule* Pipeline::ComputeSchedule(ZonePool* zone_pool, Graph* graph) {
- PhaseStats schedule_stats(info(), zone_pool, PhaseStats::CODEGEN,
- "scheduling");
Schedule* schedule = Scheduler::ComputeSchedule(zone_pool, graph);
TraceSchedule(schedule);
if (VerifyGraphs()) ScheduleVerifier::Run(schedule);
@@ -446,8 +405,8 @@
TraceSchedule(schedule);
SourcePositionTable source_positions(graph);
- Handle<Code> code =
- GenerateCode(&zone_pool, linkage, graph, schedule,
&source_positions);
+ Handle<Code> code = GenerateCode(NULL, &zone_pool, linkage, graph,
schedule,
+ &source_positions);
#if ENABLE_DISASSEMBLER
if (!code.is_null() && FLAG_print_opt_code) {
CodeTracer::Scope tracing_scope(isolate()->GetCodeTracer());
@@ -459,7 +418,8 @@
}
-Handle<Code> Pipeline::GenerateCode(ZonePool* zone_pool, Linkage* linkage,
+Handle<Code> Pipeline::GenerateCode(PipelineStatistics*
pipeline_statistics,
+ ZonePool* zone_pool, Linkage* linkage,
Graph* graph, Schedule* schedule,
SourcePositionTable* source_positions)
{
DCHECK_NOT_NULL(graph);
@@ -477,6 +437,7 @@
// Select and schedule instructions covering the scheduled graph.
{
+ PhaseScope phase_scope(pipeline_statistics, "select instructions");
ZonePool::Scope zone_scope(zone_pool);
InstructionSelector selector(zone_scope.zone(), linkage, &sequence,
schedule, source_positions);
@@ -502,7 +463,7 @@
ZonePool::Scope zone_scope(zone_pool);
RegisterAllocator allocator(zone_scope.zone(), &frame, linkage->info(),
&sequence);
- if (!allocator.Allocate(zone_pool)) {
+ if (!allocator.Allocate(pipeline_statistics)) {
linkage->info()->AbortOptimization(kNotEnoughVirtualRegistersRegalloc);
return Handle<Code>::null();
}
@@ -518,8 +479,12 @@
}
// Generate native sequence.
- CodeGenerator generator(&frame, linkage, &sequence);
- Handle<Code> code = generator.GenerateCode();
+ 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;
=======================================
--- /branches/bleeding_edge/src/compiler/pipeline.h Thu Oct 23 07:36:39
2014 UTC
+++ /branches/bleeding_edge/src/compiler/pipeline.h Thu Oct 23 09:14:35
2014 UTC
@@ -22,6 +22,7 @@
class Graph;
class InstructionSequence;
class Linkage;
+class PipelineStatistics;
class RegisterAllocator;
class Schedule;
class SourcePositionTable;
@@ -61,7 +62,8 @@
void PrintAllocator(const char* phase, const RegisterAllocator*
allocator);
void VerifyAndPrintGraph(Graph* graph, const char* phase,
bool untyped = false);
- Handle<Code> GenerateCode(ZonePool* zone_pool, Linkage* linkage, Graph*
graph,
+ Handle<Code> GenerateCode(PipelineStatistics* pipeline_statistics,
+ ZonePool* zone_pool, Linkage* linkage, Graph*
graph,
Schedule* schedule,
SourcePositionTable* source_positions);
};
=======================================
--- /branches/bleeding_edge/src/compiler/register-allocator.cc Tue Oct 21
14:44:50 2014 UTC
+++ /branches/bleeding_edge/src/compiler/register-allocator.cc Thu Oct 23
09:14:35 2014 UTC
@@ -2,10 +2,9 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#include "src/compiler/register-allocator.h"
-
#include "src/compiler/linkage.h"
-#include "src/hydrogen.h"
+#include "src/compiler/pipeline-statistics.h"
+#include "src/compiler/register-allocator.h"
#include "src/string-stream.h"
namespace v8 {
@@ -503,7 +502,6 @@
CompilationInfo* info,
InstructionSequence* code)
: zone_(local_zone),
- zone_pool_(NULL),
frame_(frame),
info_(info),
code_(code),
@@ -1096,72 +1094,53 @@
}
-bool RegisterAllocator::Allocate(ZonePool* zone_pool) {
- DCHECK_EQ(NULL, zone_pool_);
- zone_pool_ = zone_pool;
+bool RegisterAllocator::Allocate(PipelineStatistics* stats) {
assigned_registers_ = new (code_zone())
BitVector(Register::NumAllocatableRegisters(), code_zone());
assigned_double_registers_ = new (code_zone())
BitVector(DoubleRegister::NumAllocatableAliasedRegisters(),
code_zone());
- MeetRegisterConstraints();
+ {
+ PhaseScope phase_scope(stats, "meet register constraints");
+ MeetRegisterConstraints();
+ }
if (!AllocationOk()) return false;
- ResolvePhis();
- BuildLiveRanges();
- AllocateGeneralRegisters();
+ {
+ PhaseScope phase_scope(stats, "resolve phis");
+ ResolvePhis();
+ }
+ {
+ PhaseScope phase_scope(stats, "build live ranges");
+ BuildLiveRanges();
+ }
+ {
+ PhaseScope phase_scope(stats, "allocate general registers");
+ AllocateGeneralRegisters();
+ }
if (!AllocationOk()) return false;
- AllocateDoubleRegisters();
+ {
+ PhaseScope phase_scope(stats, "allocate double registers");
+ AllocateDoubleRegisters();
+ }
if (!AllocationOk()) return false;
- PopulatePointerMaps();
- ConnectRanges();
- ResolveControlFlow();
+ {
+ PhaseScope phase_scope(stats, "populate pointer maps");
+ PopulatePointerMaps();
+ }
+ {
+ PhaseScope phase_scope(stats, "connect ranges");
+ ConnectRanges();
+ }
+ {
+ PhaseScope phase_scope(stats, "resolve control flow");
+ ResolveControlFlow();
+ }
frame()->SetAllocatedRegisters(assigned_registers_);
frame()->SetAllocatedDoubleRegisters(assigned_double_registers_);
return true;
}
-class RegisterAllocatorPhase : public CompilationPhase {
- public:
- RegisterAllocatorPhase(const char* name, RegisterAllocator* allocator)
- : CompilationPhase(name, allocator->info()),
- allocator_(allocator),
- allocator_zone_start_allocation_size_(0),
- stats_(NULL) {
- if (FLAG_turbo_stats) {
- allocator_zone_start_allocation_size_ =
- allocator->info()->zone()->allocation_size();
- if (allocator->zone_pool() != NULL) {
- stats_ = new ZonePool::StatsScope(allocator->zone_pool());
- }
- }
- }
-
- ~RegisterAllocatorPhase() {
- if (FLAG_turbo_stats) {
- unsigned size = allocator_->info()->zone()->allocation_size() -
- allocator_zone_start_allocation_size_;
- if (stats_ != NULL) {
- size += static_cast<unsigned>(stats_->GetMaxAllocatedBytes());
- }
- isolate()->GetTStatistics()->SaveTiming(name(), base::TimeDelta(),
size);
- }
- delete stats_;
-#ifdef DEBUG
- if (allocator_ != NULL) allocator_->Verify();
-#endif
- }
-
- private:
- RegisterAllocator* allocator_;
- unsigned allocator_zone_start_allocation_size_;
- ZonePool::StatsScope* stats_;
-
- DISALLOW_COPY_AND_ASSIGN(RegisterAllocatorPhase);
-};
-
-
void RegisterAllocator::MeetRegisterConstraints() {
- RegisterAllocatorPhase phase("L_Register constraints", this);
for (int i = 0; i < code()->InstructionBlockCount(); ++i) {
MeetRegisterConstraints(
code()->InstructionBlockAt(BasicBlock::RpoNumber::FromInt(i)));
@@ -1171,8 +1150,6 @@
void RegisterAllocator::ResolvePhis() {
- RegisterAllocatorPhase phase("L_Resolve phis", this);
-
// Process the blocks in reverse order.
for (int i = code()->InstructionBlockCount() - 1; i >= 0; --i) {
ResolvePhis(code()->InstructionBlockAt(BasicBlock::RpoNumber::FromInt(i)));
@@ -1250,7 +1227,6 @@
void RegisterAllocator::ConnectRanges() {
- RegisterAllocatorPhase phase("L_Connect ranges", this);
for (int i = 0; i < live_ranges()->length(); ++i) {
LiveRange* first_range = live_ranges()->at(i);
if (first_range == NULL || first_range->parent() != NULL) continue;
@@ -1294,7 +1270,6 @@
void RegisterAllocator::ResolveControlFlow() {
- RegisterAllocatorPhase phase("L_Resolve control flow", this);
for (int block_id = 1; block_id < code()->InstructionBlockCount();
++block_id) {
const InstructionBlock* block =
@@ -1316,7 +1291,6 @@
void RegisterAllocator::BuildLiveRanges() {
- RegisterAllocatorPhase phase("L_Build live ranges", this);
InitializeLivenessAnalysis();
// Process the blocks in reverse order.
for (int block_id = code()->InstructionBlockCount() - 1; block_id >= 0;
@@ -1457,8 +1431,6 @@
void RegisterAllocator::PopulatePointerMaps() {
- RegisterAllocatorPhase phase("L_Populate pointer maps", this);
-
DCHECK(SafePointsAreInOrder());
// Iterate over all safe point positions and record a pointer
@@ -1541,7 +1513,6 @@
void RegisterAllocator::AllocateGeneralRegisters() {
- RegisterAllocatorPhase phase("L_Allocate general registers", this);
num_registers_ = Register::NumAllocatableRegisters();
mode_ = GENERAL_REGISTERS;
AllocateRegisters();
@@ -1549,7 +1520,6 @@
void RegisterAllocator::AllocateDoubleRegisters() {
- RegisterAllocatorPhase phase("L_Allocate double registers", this);
num_registers_ = DoubleRegister::NumAllocatableAliasedRegisters();
mode_ = DOUBLE_REGISTERS;
AllocateRegisters();
=======================================
--- /branches/bleeding_edge/src/compiler/register-allocator.h Tue Oct 21
14:44:50 2014 UTC
+++ /branches/bleeding_edge/src/compiler/register-allocator.h Thu Oct 23
09:14:35 2014 UTC
@@ -23,6 +23,8 @@
namespace compiler {
+class PipelineStatistics;
+
enum RegisterKind {
UNALLOCATED_REGISTERS,
GENERAL_REGISTERS,
@@ -331,8 +333,7 @@
// Returns the register kind required by the given virtual register.
RegisterKind RequiredRegisterKind(int virtual_register) const;
- // TODO(dcarney): fix compilation phase stats to not require this.
- bool Allocate(ZonePool* zone_pool = NULL);
+ bool Allocate(PipelineStatistics* stats = NULL);
const ZoneList<LiveRange*>* live_ranges() const { return &live_ranges_; }
const Vector<LiveRange*>* fixed_live_ranges() const {
@@ -344,7 +345,6 @@
CompilationInfo* info() const { return info_; }
inline InstructionSequence* code() const { return code_; }
- ZonePool* zone_pool() const { return zone_pool_; }
// This zone is for datastructures only needed during register
allocation.
inline Zone* zone() const { return zone_; }
@@ -501,8 +501,6 @@
Frame* frame() const { return frame_; }
Zone* const zone_;
- // TODO(dcarney): remove this.
- ZonePool* zone_pool_;
Frame* const frame_;
CompilationInfo* const info_;
InstructionSequence* const code_;
=======================================
--- /branches/bleeding_edge/src/compiler/zone-pool.cc Tue Oct 21 12:38:46
2014 UTC
+++ /branches/bleeding_edge/src/compiler/zone-pool.cc Thu Oct 23 09:14:35
2014 UTC
@@ -9,7 +9,9 @@
namespace compiler {
ZonePool::StatsScope::StatsScope(ZonePool* zone_pool)
- : zone_pool_(zone_pool), max_allocated_bytes_(0) {
+ : zone_pool_(zone_pool),
+ total_allocated_bytes_at_start_(zone_pool->GetTotalAllocatedBytes()),
+ max_allocated_bytes_(0) {
zone_pool_->stats_.push_back(this);
for (auto zone : zone_pool_->used_) {
size_t size = static_cast<size_t>(zone->allocation_size());
@@ -44,6 +46,11 @@
}
return total;
}
+
+
+size_t ZonePool::StatsScope::GetTotalAllocatedBytes() {
+ return zone_pool_->GetTotalAllocatedBytes() -
total_allocated_bytes_at_start_;
+}
void ZonePool::StatsScope::ZoneReturned(Zone* zone) {
=======================================
--- /branches/bleeding_edge/src/compiler/zone-pool.h Tue Oct 21 12:38:46
2014 UTC
+++ /branches/bleeding_edge/src/compiler/zone-pool.h Thu Oct 23 09:14:35
2014 UTC
@@ -44,6 +44,7 @@
size_t GetMaxAllocatedBytes();
size_t GetCurrentAllocatedBytes();
+ size_t GetTotalAllocatedBytes();
private:
friend class ZonePool;
@@ -53,6 +54,7 @@
ZonePool* const zone_pool_;
InitialValues initial_values_;
+ size_t total_allocated_bytes_at_start_;
size_t max_allocated_bytes_;
DISALLOW_COPY_AND_ASSIGN(StatsScope);
=======================================
--- /branches/bleeding_edge/src/hydrogen.cc Thu Oct 23 05:57:01 2014 UTC
+++ /branches/bleeding_edge/src/hydrogen.cc Thu Oct 23 09:14:35 2014 UTC
@@ -12594,15 +12594,14 @@
}
-void HStatistics::Print(const char* stats_name) {
+void HStatistics::Print() {
PrintF(
"\n"
"----------------------------------------"
"----------------------------------------\n"
- "--- %s timing results:\n"
+ "--- Hydrogen timing results:\n"
"----------------------------------------"
- "----------------------------------------\n",
- stats_name);
+ "----------------------------------------\n");
base::TimeDelta sum;
for (int i = 0; i < times_.length(); ++i) {
sum += times_[i];
=======================================
--- /branches/bleeding_edge/src/hydrogen.h Wed Oct 15 12:22:15 2014 UTC
+++ /branches/bleeding_edge/src/hydrogen.h Thu Oct 23 09:14:35 2014 UTC
@@ -2760,7 +2760,7 @@
source_size_(0) { }
void Initialize(CompilationInfo* info);
- void Print(const char* stats_name);
+ void Print();
void SaveTiming(const char* name, base::TimeDelta time, unsigned size);
void IncrementFullCodeGen(base::TimeDelta full_code_gen) {
=======================================
--- /branches/bleeding_edge/src/isolate.cc Thu Oct 23 08:43:17 2014 UTC
+++ /branches/bleeding_edge/src/isolate.cc Thu Oct 23 09:14:35 2014 UTC
@@ -5,6 +5,7 @@
#include <stdlib.h>
#include <fstream> // NOLINT(readability/streams)
+#include <iostream> // NOLINT(readability/streams)
#include "src/v8.h"
@@ -16,6 +17,7 @@
#include "src/bootstrapper.h"
#include "src/codegen.h"
#include "src/compilation-cache.h"
+#include "src/compilation-statistics.h"
#include "src/cpu-profiler.h"
#include "src/debug.h"
#include "src/deoptimizer.h"
@@ -1606,8 +1608,10 @@
heap_.mark_compact_collector()->EnsureSweepingCompleted();
}
- if (FLAG_turbo_stats) GetTStatistics()->Print("TurboFan");
- if (FLAG_hydrogen_stats) GetHStatistics()->Print("Hydrogen");
+ if (turbo_statistics() != NULL) {
+ std::cout << *turbo_statistics() << std::endl;
+ }
+ if (FLAG_hydrogen_stats) GetHStatistics()->Print();
if (FLAG_print_deopt_stress) {
PrintF(stdout, "=== Stress deopt counter: %u\n", stress_deopt_count_);
@@ -2119,9 +2123,10 @@
}
-HStatistics* Isolate::GetTStatistics() {
- if (tstatistics() == NULL) set_tstatistics(new HStatistics());
- return tstatistics();
+CompilationStatistics* Isolate::GetTurboStatistics() {
+ if (turbo_statistics() == NULL)
+ set_turbo_statistics(new CompilationStatistics());
+ return turbo_statistics();
}
=======================================
--- /branches/bleeding_edge/src/isolate.h Thu Oct 23 07:36:39 2014 UTC
+++ /branches/bleeding_edge/src/isolate.h Thu Oct 23 09:14:35 2014 UTC
@@ -40,6 +40,7 @@
class CodeStubDescriptor;
class CodeTracer;
class CompilationCache;
+class CompilationStatistics;
class ContextSlotCache;
class Counters;
class CpuFeatures;
@@ -383,7 +384,7 @@
V(int, pending_microtask_count,
0) \
V(bool, autorun_microtasks,
true) \
V(HStatistics*, hstatistics,
NULL) \
- V(HStatistics*, tstatistics,
NULL) \
+ V(CompilationStatistics*, turbo_statistics,
NULL) \
V(HTracer*, htracer,
NULL) \
V(CodeTracer*, code_tracer,
NULL) \
V(bool, fp_stubs_generated,
false) \
@@ -1052,7 +1053,7 @@
int id() const { return static_cast<int>(id_); }
HStatistics* GetHStatistics();
- HStatistics* GetTStatistics();
+ CompilationStatistics* GetTurboStatistics();
HTracer* GetHTracer();
CodeTracer* GetCodeTracer();
=======================================
--- /branches/bleeding_edge/test/unittests/compiler/zone-pool-unittest.cc
Tue Oct 21 12:38:46 2014 UTC
+++ /branches/bleeding_edge/test/unittests/compiler/zone-pool-unittest.cc
Thu Oct 23 09:14:35 2014 UTC
@@ -23,9 +23,11 @@
ASSERT_EQ(total, zone_pool()->GetTotalAllocatedBytes());
}
- void Expect(ZonePool::StatsScope* stats, size_t current, size_t max) {
+ void Expect(ZonePool::StatsScope* stats, size_t current, size_t max,
+ size_t total) {
ASSERT_EQ(current, stats->GetCurrentAllocatedBytes());
ASSERT_EQ(max, stats->GetMaxAllocatedBytes());
+ ASSERT_EQ(total, stats->GetTotalAllocatedBytes());
}
size_t Allocate(Zone* zone) {
@@ -45,7 +47,7 @@
ExpectForPool(0, 0, 0);
{
ZonePool::StatsScope stats(zone_pool());
- Expect(&stats, 0, 0);
+ Expect(&stats, 0, 0, 0);
}
ExpectForPool(0, 0, 0);
{
@@ -77,7 +79,7 @@
before_deletion += Allocate(scopes[i]->zone()); // Add some stuff.
}
- Expect(&stats, before_deletion, before_deletion);
+ Expect(&stats, before_deletion, before_deletion, before_deletion);
ExpectForPool(before_stats + before_deletion, before_stats +
before_deletion,
before_stats + before_deletion);
@@ -87,7 +89,7 @@
scopes[i] = new ZonePool::Scope(zone_pool());
}
- Expect(&stats, 0, before_deletion);
+ Expect(&stats, 0, before_deletion, before_deletion);
ExpectForPool(0, before_stats + before_deletion,
before_stats + before_deletion);
@@ -96,7 +98,8 @@
after_deletion += Allocate(scopes[i]->zone()); // Add some stuff.
}
- Expect(&stats, after_deletion, std::max(after_deletion,
before_deletion));
+ Expect(&stats, after_deletion, std::max(after_deletion, before_deletion),
+ before_deletion + after_deletion);
ExpectForPool(after_deletion,
std::max(after_deletion, before_stats + before_deletion),
before_stats + before_deletion + after_deletion);
@@ -106,7 +109,8 @@
delete scopes[i];
}
- Expect(&stats, 0, std::max(after_deletion, before_deletion));
+ Expect(&stats, 0, std::max(after_deletion, before_deletion),
+ before_deletion + after_deletion);
ExpectForPool(0, std::max(after_deletion, before_stats +
before_deletion),
before_stats + before_deletion + after_deletion);
}
@@ -136,19 +140,20 @@
total_allocated += bytes;
max_loop_allocation =
std::max(max_loop_allocation, outer_allocated + allocated);
- Expect(&inner_stats, allocated, allocated);
- Expect(&outer_stats, outer_allocated + allocated,
- max_loop_allocation);
+ Expect(&inner_stats, allocated, allocated, allocated);
+ Expect(&outer_stats, outer_allocated + allocated,
max_loop_allocation,
+ total_allocated);
ExpectForPool(outer_allocated + allocated, max_loop_allocation,
total_allocated);
}
}
- Expect(&inner_stats, 0, allocated);
- Expect(&outer_stats, outer_allocated, max_loop_allocation);
+ Expect(&inner_stats, 0, allocated, allocated);
+ Expect(&outer_stats, outer_allocated, max_loop_allocation,
+ total_allocated);
ExpectForPool(outer_allocated, max_loop_allocation, total_allocated);
}
}
- Expect(&outer_stats, 0, max_loop_allocation);
+ Expect(&outer_stats, 0, max_loop_allocation, total_allocated);
ExpectForPool(0, max_loop_allocation, total_allocated);
}
=======================================
--- /branches/bleeding_edge/tools/gyp/v8.gyp Tue Oct 21 17:21:32 2014 UTC
+++ /branches/bleeding_edge/tools/gyp/v8.gyp Thu Oct 23 09:14:35 2014 UTC
@@ -387,6 +387,8 @@
'../../src/codegen.h',
'../../src/compilation-cache.cc',
'../../src/compilation-cache.h',
+ '../../src/compilation-statistics.cc',
+ '../../src/compilation-statistics.h',
'../../src/compiler/access-builder.cc',
'../../src/compiler/access-builder.h',
'../../src/compiler/ast-graph-builder.cc',
@@ -473,6 +475,8 @@
'../../src/compiler/phi-reducer.h',
'../../src/compiler/pipeline.cc',
'../../src/compiler/pipeline.h',
+ '../../src/compiler/pipeline-statistics.cc',
+ '../../src/compiler/pipeline-statistics.h',
'../../src/compiler/raw-machine-assembler.cc',
'../../src/compiler/raw-machine-assembler.h',
'../../src/compiler/register-allocator.cc',
--
--
v8-dev mailing list
[email protected]
http://groups.google.com/group/v8-dev
---
You received this message because you are subscribed to the Google Groups "v8-dev" group.
To unsubscribe from this group and stop receiving emails from it, send an email
to [email protected].
For more options, visit https://groups.google.com/d/optout.
