From 5250da68611dcac588b49e29f4671707bda10b14 Mon Sep 17 00:00:00 2001 From: bmeurer Date: Thu, 23 Jun 2016 01:56:42 -0700 Subject: [PATCH] [turbofan] Initial version of RedundancyElimination. The redundancy elimination is currently a graph reducer that tries to combine redundant checks in the effect chain. It does this by propagating the checks that happened along effect paths, which is pretty similar to what the BranchElimination does on the control chain. We run this reducer together with the other optimizations right after the representation selection. An upcoming CL will extend the redundancy elimination to also eliminate redundant loads (and eventually map checks). R=jarin@chromium.org BUG=v8:5141 Review-Url: https://codereview.chromium.org/2091503003 Cr-Commit-Position: refs/heads/master@{#37208} --- BUILD.gn | 2 + src/compiler/pipeline.cc | 3 + src/compiler/redundancy-elimination.cc | 216 +++++++++++++++++++++++++ src/compiler/redundancy-elimination.h | 76 +++++++++ src/v8.gyp | 2 + 5 files changed, 299 insertions(+) create mode 100644 src/compiler/redundancy-elimination.cc create mode 100644 src/compiler/redundancy-elimination.h diff --git a/BUILD.gn b/BUILD.gn index 5f7a2033a3..d4a8e1b4f0 100644 --- a/BUILD.gn +++ b/BUILD.gn @@ -974,6 +974,8 @@ v8_source_set("v8_base") { "src/compiler/pipeline.h", "src/compiler/raw-machine-assembler.cc", "src/compiler/raw-machine-assembler.h", + "src/compiler/redundancy-elimination.cc", + "src/compiler/redundancy-elimination.h", "src/compiler/register-allocator-verifier.cc", "src/compiler/register-allocator-verifier.h", "src/compiler/register-allocator.cc", diff --git a/src/compiler/pipeline.cc b/src/compiler/pipeline.cc index 4aa91716da..11443e71cc 100644 --- a/src/compiler/pipeline.cc +++ b/src/compiler/pipeline.cc @@ -49,6 +49,7 @@ #include "src/compiler/move-optimizer.h" #include "src/compiler/osr.h" #include "src/compiler/pipeline-statistics.h" +#include "src/compiler/redundancy-elimination.h" #include "src/compiler/register-allocator-verifier.h" #include "src/compiler/register-allocator.h" #include "src/compiler/schedule.h" @@ -973,12 +974,14 @@ struct EarlyOptimizationPhase { DeadCodeElimination dead_code_elimination(&graph_reducer, data->graph(), data->common()); SimplifiedOperatorReducer simple_reducer(&graph_reducer, data->jsgraph()); + RedundancyElimination redundancy_elimination(&graph_reducer, temp_zone); ValueNumberingReducer value_numbering(temp_zone); MachineOperatorReducer machine_reducer(data->jsgraph()); CommonOperatorReducer common_reducer(&graph_reducer, data->graph(), data->common(), data->machine()); AddReducer(data, &graph_reducer, &dead_code_elimination); AddReducer(data, &graph_reducer, &simple_reducer); + AddReducer(data, &graph_reducer, &redundancy_elimination); AddReducer(data, &graph_reducer, &generic_lowering); AddReducer(data, &graph_reducer, &value_numbering); AddReducer(data, &graph_reducer, &machine_reducer); diff --git a/src/compiler/redundancy-elimination.cc b/src/compiler/redundancy-elimination.cc new file mode 100644 index 0000000000..ae87349896 --- /dev/null +++ b/src/compiler/redundancy-elimination.cc @@ -0,0 +1,216 @@ +// Copyright 2016 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/redundancy-elimination.h" + +#include "src/compiler/node-properties.h" + +namespace v8 { +namespace internal { +namespace compiler { + +RedundancyElimination::RedundancyElimination(Editor* editor, Zone* zone) + : AdvancedReducer(editor), node_checks_(zone), zone_(zone) {} + +RedundancyElimination::~RedundancyElimination() {} + +Reduction RedundancyElimination::Reduce(Node* node) { + switch (node->opcode()) { + case IrOpcode::kCheckFloat64Hole: + case IrOpcode::kCheckTaggedHole: + case IrOpcode::kCheckTaggedPointer: + case IrOpcode::kCheckTaggedSigned: + case IrOpcode::kCheckedFloat64ToInt32: + case IrOpcode::kCheckedInt32Add: + case IrOpcode::kCheckedInt32Sub: + case IrOpcode::kCheckedTaggedToFloat64: + case IrOpcode::kCheckedTaggedToInt32: + case IrOpcode::kCheckedUint32ToInt32: + return ReduceCheckNode(node); + case IrOpcode::kEffectPhi: + return ReduceEffectPhi(node); + case IrOpcode::kDead: + break; + case IrOpcode::kStart: + return ReduceStart(node); + default: + return ReduceOtherNode(node); + } + return NoChange(); +} + +// static +RedundancyElimination::EffectPathChecks* +RedundancyElimination::EffectPathChecks::Copy(Zone* zone, + EffectPathChecks const* checks) { + return new (zone->New(sizeof(EffectPathChecks))) EffectPathChecks(*checks); +} + +// static +RedundancyElimination::EffectPathChecks const* +RedundancyElimination::EffectPathChecks::Empty(Zone* zone) { + return new (zone->New(sizeof(EffectPathChecks))) EffectPathChecks(nullptr, 0); +} + +void RedundancyElimination::EffectPathChecks::Merge( + EffectPathChecks const* that) { + // Change the current check list to a longest common tail of this check + // list and the other list. + + // First, we throw away the prefix of the longer list, so that + // we have lists of the same length. + Check* that_head = that->head_; + size_t that_size = that->size_; + while (that_size > size_) { + that_head = that_head->next; + that_size--; + } + while (size_ > that_size) { + head_ = head_->next; + size_--; + } + + // Then we go through both lists in lock-step until we find + // the common tail. + while (head_ != that_head) { + DCHECK_LT(0u, size_); + DCHECK_NOT_NULL(head_); + size_--; + head_ = head_->next; + that_head = that_head->next; + } +} + +RedundancyElimination::EffectPathChecks const* +RedundancyElimination::EffectPathChecks::AddCheck(Zone* zone, + Node* node) const { + Check* head = new (zone->New(sizeof(Check))) Check(node, head_); + return new (zone->New(sizeof(EffectPathChecks))) + EffectPathChecks(head, size_ + 1); +} + +namespace { + +bool IsCompatibleCheck(Node const* a, Node const* b) { + if (a->op() != b->op()) return false; + for (int i = a->op()->ValueInputCount(); --i >= 0;) { + if (a->InputAt(i) != b->InputAt(i)) return false; + } + return true; +} + +} // namespace + +Node* RedundancyElimination::EffectPathChecks::LookupCheck(Node* node) const { + for (Check const* check = head_; check != nullptr; check = check->next) { + if (IsCompatibleCheck(check->node, node)) { + DCHECK(!check->node->IsDead()); + return check->node; + } + } + return nullptr; +} + +RedundancyElimination::EffectPathChecks const* +RedundancyElimination::PathChecksForEffectNodes::Get(Node* node) const { + size_t const id = node->id(); + if (id < info_for_node_.size()) return info_for_node_[id]; + return nullptr; +} + +void RedundancyElimination::PathChecksForEffectNodes::Set( + Node* node, EffectPathChecks const* checks) { + size_t const id = node->id(); + if (id >= info_for_node_.size()) info_for_node_.resize(id + 1, nullptr); + info_for_node_[id] = checks; +} + +Reduction RedundancyElimination::ReduceCheckNode(Node* node) { + Node* const effect = NodeProperties::GetEffectInput(node); + EffectPathChecks const* checks = node_checks_.Get(effect); + // If we do not know anything about the predecessor, do not propagate just yet + // because we will have to recompute anyway once we compute the predecessor. + if (checks == nullptr) return NoChange(); + // See if we have another check that dominates us. + if (Node* check = checks->LookupCheck(node)) { + ReplaceWithValue(node, check); + return Replace(check); + } + // Learn from this check. + return UpdateChecks(node, checks->AddCheck(zone(), node)); +} + +Reduction RedundancyElimination::ReduceEffectPhi(Node* node) { + Node* const control = NodeProperties::GetControlInput(node); + if (control->opcode() == IrOpcode::kLoop) { + // Here we rely on having only reducible loops: + // The loop entry edge always dominates the header, so we can just use + // the information from the loop entry edge. + return TakeChecksFromFirstEffect(node); + } + DCHECK_EQ(IrOpcode::kMerge, control->opcode()); + + // Shortcut for the case when we do not know anything about some input. + int const input_count = node->op()->EffectInputCount(); + for (int i = 0; i < input_count; ++i) { + Node* const effect = NodeProperties::GetEffectInput(node, i); + if (node_checks_.Get(effect) == nullptr) return NoChange(); + } + + // Make a copy of the first input's checks and merge with the checks + // from other inputs. + EffectPathChecks* checks = EffectPathChecks::Copy( + zone(), node_checks_.Get(NodeProperties::GetEffectInput(node, 0))); + for (int i = 1; i < input_count; ++i) { + Node* const input = NodeProperties::GetEffectInput(node, i); + checks->Merge(node_checks_.Get(input)); + } + return UpdateChecks(node, checks); +} + +Reduction RedundancyElimination::ReduceStart(Node* node) { + return UpdateChecks(node, EffectPathChecks::Empty(zone())); +} + +Reduction RedundancyElimination::ReduceOtherNode(Node* node) { + if (node->op()->EffectInputCount() == 1) { + if (node->op()->EffectOutputCount() == 1) { + return TakeChecksFromFirstEffect(node); + } else { + // Effect terminators should be handled specially. + return NoChange(); + } + } + DCHECK_EQ(0, node->op()->EffectInputCount()); + DCHECK_EQ(0, node->op()->EffectOutputCount()); + return NoChange(); +} + +Reduction RedundancyElimination::TakeChecksFromFirstEffect(Node* node) { + DCHECK_EQ(1, node->op()->EffectOutputCount()); + Node* const effect = NodeProperties::GetEffectInput(node); + EffectPathChecks const* checks = node_checks_.Get(effect); + // If we do not know anything about the predecessor, do not propagate just yet + // because we will have to recompute anyway once we compute the predecessor. + if (checks == nullptr) return NoChange(); + // We just propagate the information from the effect input (ideally, + // we would only revisit effect uses if there is change). + return UpdateChecks(node, checks); +} + +Reduction RedundancyElimination::UpdateChecks(Node* node, + EffectPathChecks const* checks) { + EffectPathChecks const* original = node_checks_.Get(node); + // Only signal that the {node} has Changed, if the information about {checks} + // has changed wrt. the {original}. + if (checks != original) { + node_checks_.Set(node, checks); + return Changed(node); + } + return NoChange(); +} + +} // namespace compiler +} // namespace internal +} // namespace v8 diff --git a/src/compiler/redundancy-elimination.h b/src/compiler/redundancy-elimination.h new file mode 100644 index 0000000000..a4886e4b91 --- /dev/null +++ b/src/compiler/redundancy-elimination.h @@ -0,0 +1,76 @@ +// Copyright 2016 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_REDUNDANCY_ELIMINATION_H_ +#define V8_COMPILER_REDUNDANCY_ELIMINATION_H_ + +#include "src/compiler/graph-reducer.h" + +namespace v8 { +namespace internal { +namespace compiler { + +class RedundancyElimination final : public AdvancedReducer { + public: + RedundancyElimination(Editor* editor, Zone* zone); + ~RedundancyElimination() final; + + Reduction Reduce(Node* node) final; + + private: + struct Check { + Check(Node* node, Check* next) : node(node), next(next) {} + Node* node; + Check* next; + }; + + class EffectPathChecks final { + public: + static EffectPathChecks* Copy(Zone* zone, EffectPathChecks const* checks); + static EffectPathChecks const* Empty(Zone* zone); + void Merge(EffectPathChecks const* that); + + EffectPathChecks const* AddCheck(Zone* zone, Node* node) const; + Node* LookupCheck(Node* node) const; + + private: + EffectPathChecks(Check* head, size_t size) : head_(head), size_(size) {} + + // We keep track of the list length so that we can find the longest + // common tail easily. + Check* head_; + size_t size_; + }; + + class PathChecksForEffectNodes final { + public: + explicit PathChecksForEffectNodes(Zone* zone) : info_for_node_(zone) {} + EffectPathChecks const* Get(Node* node) const; + void Set(Node* node, EffectPathChecks const* checks); + + private: + ZoneVector info_for_node_; + }; + + Reduction ReduceCheckNode(Node* node); + Reduction ReduceEffectPhi(Node* node); + Reduction ReduceStart(Node* node); + Reduction ReduceOtherNode(Node* node); + + Reduction TakeChecksFromFirstEffect(Node* node); + Reduction UpdateChecks(Node* node, EffectPathChecks const* checks); + + Zone* zone() const { return zone_; } + + PathChecksForEffectNodes node_checks_; + Zone* const zone_; + + DISALLOW_COPY_AND_ASSIGN(RedundancyElimination); +}; + +} // namespace compiler +} // namespace internal +} // namespace v8 + +#endif // V8_COMPILER_REDUNDANCY_ELIMINATION_H_ diff --git a/src/v8.gyp b/src/v8.gyp index 1f6c0dafe2..e289cfa8f1 100644 --- a/src/v8.gyp +++ b/src/v8.gyp @@ -638,6 +638,8 @@ 'compiler/pipeline-statistics.h', 'compiler/raw-machine-assembler.cc', 'compiler/raw-machine-assembler.h', + 'compiler/redundancy-elimination.cc', + 'compiler/redundancy-elimination.h', 'compiler/register-allocator.cc', 'compiler/register-allocator.h', 'compiler/register-allocator-verifier.cc',