[SLP]Fix/improve minbitwidth mapping to use TreeEntry as a key. #73567
Conversation
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
|
@llvm/pr-subscribers-llvm-transforms Author: Alexey Bataev (alexey-bataev) ChangesCurrently, MinBWs map uses Value* as a key and stores mapping for each Full diff: https://github.com/llvm/llvm-project/pull/73567.diff 2 Files Affected:
diff --git a/llvm/lib/Transforms/Vectorize/SLPVectorizer.cpp b/llvm/lib/Transforms/Vectorize/SLPVectorizer.cpp
index 8276beb004f22a5..e445ee7a0b06ff2 100644
--- a/llvm/lib/Transforms/Vectorize/SLPVectorizer.cpp
+++ b/llvm/lib/Transforms/Vectorize/SLPVectorizer.cpp
@@ -2287,9 +2287,13 @@ class BoUpSLP {
/// a smaller type with a truncation. We collect the values that will be
/// demoted in ToDemote and additional roots that require investigating in
/// Roots.
- bool collectValuesToDemote(Value *V, SmallVectorImpl<Value *> &ToDemote,
- SmallVectorImpl<Value *> &Roots,
- DenseSet<Value *> &Visited) const;
+ /// \param DemotedConsts list of Instruction/OperandIndex pairs that are
+ /// constant and to be demoted. Required to correctly identify constant nodes
+ /// to be demoted.
+ bool collectValuesToDemote(
+ Value *V, SmallVectorImpl<Value *> &ToDemote,
+ DenseMap<Instruction *, SmallVector<unsigned>> &DemotedConsts,
+ SmallVectorImpl<Value *> &Roots, DenseSet<Value *> &Visited) const;
/// Check if the operands on the edges \p Edges of the \p UserTE allows
/// reordering (i.e. the operands can be reordered because they have only one
@@ -2352,6 +2356,9 @@ class BoUpSLP {
/// of a vector of (the same) instruction.
TargetTransformInfo::OperandValueInfo getOperandInfo(ArrayRef<Value *> Ops);
+ /// \ returns the graph entry for the \p Idx operand of the \p E entry.
+ const TreeEntry *getOperandEntry(const TreeEntry *E, unsigned Idx) const;
+
/// \returns the cost of the vectorizable entry.
InstructionCost getEntryCost(const TreeEntry *E,
ArrayRef<Value *> VectorizedVals,
@@ -3594,7 +3601,7 @@ class BoUpSLP {
/// where "width" indicates the minimum bit width and "signed" is True if the
/// value must be signed-extended, rather than zero-extended, back to its
/// original width.
- DenseMap<Value *, std::pair<uint64_t, bool>> MinBWs;
+ DenseMap<const TreeEntry *, std::pair<uint64_t, bool>> MinBWs;
};
} // end namespace slpvectorizer
@@ -7579,7 +7586,36 @@ class BoUpSLP::ShuffleCostEstimator : public BaseShuffleAnalysis {
assert((IsFinalized || CommonMask.empty()) &&
"Shuffle construction must be finalized.");
}
- };
+};
+
+const BoUpSLP::TreeEntry *BoUpSLP::getOperandEntry(const TreeEntry *E,
+ unsigned Idx) const {
+ Value *Op = E->getOperand(Idx).front();
+ if (const TreeEntry *TE = getTreeEntry(Op)) {
+ if (find_if(E->UserTreeIndices, [&](const EdgeInfo &EI) {
+ return EI.EdgeIdx == Idx && EI.UserTE == E;
+ }) != TE->UserTreeIndices.end())
+ return TE;
+ auto MIt = MultiNodeScalars.find(Op);
+ if (MIt != MultiNodeScalars.end()) {
+ for (const TreeEntry *TE : MIt->second) {
+ if (find_if(TE->UserTreeIndices, [&](const EdgeInfo &EI) {
+ return EI.EdgeIdx == Idx && EI.UserTE == E;
+ }) != TE->UserTreeIndices.end())
+ return TE;
+ }
+ }
+ }
+ const auto *It =
+ find_if(VectorizableTree, [&](const std::unique_ptr<TreeEntry> &TE) {
+ return TE->State == TreeEntry::NeedToGather &&
+ find_if(TE->UserTreeIndices, [&](const EdgeInfo &EI) {
+ return EI.EdgeIdx == Idx && EI.UserTE == E;
+ }) != TE->UserTreeIndices.end();
+ });
+ assert(It != VectorizableTree.end() && "Expected vectorizable entry.");
+ return It->get();
+}
InstructionCost
BoUpSLP::getEntryCost(const TreeEntry *E, ArrayRef<Value *> VectorizedVals,
@@ -7602,7 +7638,7 @@ BoUpSLP::getEntryCost(const TreeEntry *E, ArrayRef<Value *> VectorizedVals,
// If we have computed a smaller type for the expression, update VecTy so
// that the costs will be accurate.
- auto It = MinBWs.find(VL.front());
+ auto It = MinBWs.find(E);
if (It != MinBWs.end()) {
ScalarTy = IntegerType::get(F->getContext(), It->second.first);
VecTy = FixedVectorType::get(ScalarTy, VL.size());
@@ -7616,16 +7652,6 @@ BoUpSLP::getEntryCost(const TreeEntry *E, ArrayRef<Value *> VectorizedVals,
return 0;
if (isa<InsertElementInst>(VL[0]))
return InstructionCost::getInvalid();
- // The gather nodes use small bitwidth only if all operands use the same
- // bitwidth. Otherwise - use the original one.
- if (It != MinBWs.end() && any_of(VL.drop_front(), [&](Value *V) {
- auto VIt = MinBWs.find(V);
- return VIt == MinBWs.end() || VIt->second.first != It->second.first ||
- VIt->second.second != It->second.second;
- })) {
- ScalarTy = VL.front()->getType();
- VecTy = FixedVectorType::get(ScalarTy, VL.size());
- }
ShuffleCostEstimator Estimator(*TTI, VectorizedVals, *this,
CheckedExtracts);
unsigned VF = E->getVectorFactor();
@@ -7851,7 +7877,7 @@ BoUpSLP::getEntryCost(const TreeEntry *E, ArrayRef<Value *> VectorizedVals,
if ((EI.UserTE->getOpcode() != Instruction::Select ||
EI.EdgeIdx != 0) &&
It != MinBWs.end()) {
- auto UserBWIt = MinBWs.find(EI.UserTE->Scalars.front());
+ auto UserBWIt = MinBWs.find(EI.UserTE);
Type *UserScalarTy =
EI.UserTE->getOperand(EI.EdgeIdx).front()->getType();
if (UserBWIt != MinBWs.end())
@@ -8144,7 +8170,7 @@ BoUpSLP::getEntryCost(const TreeEntry *E, ArrayRef<Value *> VectorizedVals,
case Instruction::Trunc:
case Instruction::FPTrunc:
case Instruction::BitCast: {
- auto SrcIt = MinBWs.find(VL0->getOperand(0));
+ auto SrcIt = MinBWs.find(getOperandEntry(E, 0));
Type *SrcScalarTy = VL0->getOperand(0)->getType();
auto *SrcVecTy = FixedVectorType::get(SrcScalarTy, VL.size());
unsigned Opcode = ShuffleOrOp;
@@ -9009,7 +9035,7 @@ InstructionCost BoUpSLP::getTreeCost(ArrayRef<Value *> VectorizedVals) {
FirstUsers.emplace_back(VU, ScalarTE);
DemandedElts.push_back(APInt::getZero(FTy->getNumElements()));
VecId = FirstUsers.size() - 1;
- auto It = MinBWs.find(EU.Scalar);
+ auto It = MinBWs.find(ScalarTE);
if (It != MinBWs.end() && VectorCasts.insert(EU.Scalar).second) {
unsigned BWSz = It->second.second;
unsigned SrcBWSz = DL->getTypeSizeInBits(FTy->getElementType());
@@ -9052,7 +9078,7 @@ InstructionCost BoUpSLP::getTreeCost(ArrayRef<Value *> VectorizedVals) {
// for the extract and the added cost of the sign extend if needed.
auto *VecTy = FixedVectorType::get(EU.Scalar->getType(), BundleWidth);
TTI::TargetCostKind CostKind = TTI::TCK_RecipThroughput;
- auto It = MinBWs.find(EU.Scalar);
+ auto It = MinBWs.find(getTreeEntry(EU.Scalar));
if (It != MinBWs.end()) {
auto *MinTy = IntegerType::get(F->getContext(), It->second.first);
unsigned Extend =
@@ -9067,9 +9093,9 @@ InstructionCost BoUpSLP::getTreeCost(ArrayRef<Value *> VectorizedVals) {
}
// Add reduced value cost, if resized.
if (!VectorizedVals.empty()) {
- auto BWIt = MinBWs.find(VectorizableTree.front()->Scalars.front());
+ auto BWIt = MinBWs.find(VectorizableTree.front().get());
if (BWIt != MinBWs.end()) {
- Type *DstTy = BWIt->first->getType();
+ Type *DstTy = VectorizableTree.front()->Scalars.front()->getType();
unsigned OriginalSz = DL->getTypeSizeInBits(DstTy);
unsigned Opcode = Instruction::Trunc;
if (OriginalSz < BWIt->second.first)
@@ -9430,7 +9456,7 @@ BoUpSLP::isGatherShuffledSingleRegisterEntry(
Instruction &LastBundleInst = getLastInstructionInBundle(VTE);
if (&LastBundleInst == TEInsertPt || !CheckOrdering(&LastBundleInst))
continue;
- auto It = MinBWs.find(VTE->Scalars.front());
+ auto It = MinBWs.find(VTE);
// If vectorize node is demoted - do not match.
if (It != MinBWs.end() &&
It->second.first != DL->getTypeSizeInBits(V->getType()))
@@ -11068,7 +11094,7 @@ Value *BoUpSLP::vectorizeTree(TreeEntry *E, bool PostponedPHIs) {
else if (auto *IE = dyn_cast<InsertElementInst>(VL0))
ScalarTy = IE->getOperand(1)->getType();
bool IsSigned = false;
- auto It = MinBWs.find(E->Scalars.front());
+ auto It = MinBWs.find(E);
if (It != MinBWs.end()) {
ScalarTy = IntegerType::get(F->getContext(), It->second.first);
IsSigned = It->second.second;
@@ -11130,7 +11156,7 @@ Value *BoUpSLP::vectorizeTree(TreeEntry *E, bool PostponedPHIs) {
Builder.SetCurrentDebugLocation(PH->getDebugLoc());
Value *Vec = vectorizeOperand(E, i, /*PostponedPHIs=*/true);
if (VecTy != Vec->getType()) {
- assert(MinBWs.contains(PH->getIncomingValue(i)) &&
+ assert(MinBWs.contains(getOperandEntry(E, i)) &&
"Expected item in MinBWs.");
Vec = Builder.CreateIntCast(Vec, VecTy, It->second.second);
}
@@ -11167,7 +11193,7 @@ Value *BoUpSLP::vectorizeTree(TreeEntry *E, bool PostponedPHIs) {
Type *ScalarTy = Op.front()->getType();
if (cast<VectorType>(V->getType())->getElementType() != ScalarTy) {
assert(ScalarTy->isIntegerTy() && "Expected item in MinBWs.");
- std::pair<unsigned, bool> Res = MinBWs.lookup(Op.front());
+ std::pair<unsigned, bool> Res = MinBWs.lookup(getOperandEntry(E, 1));
assert(Res.first > 0 && "Expected item in MinBWs.");
V = Builder.CreateIntCast(
V,
@@ -11342,7 +11368,7 @@ Value *BoUpSLP::vectorizeTree(TreeEntry *E, bool PostponedPHIs) {
auto *CI = cast<CastInst>(VL0);
Instruction::CastOps VecOpcode = CI->getOpcode();
Type *SrcScalarTy = VL0->getOperand(0)->getType();
- auto SrcIt = MinBWs.find(VL0->getOperand(0));
+ auto SrcIt = MinBWs.find(getOperandEntry(E, 0));
if (!ScalarTy->isFloatingPointTy() && !SrcScalarTy->isFloatingPointTy() &&
(SrcIt != MinBWs.end() || It != MinBWs.end())) {
// Check if the values are candidates to demote.
@@ -11383,8 +11409,8 @@ Value *BoUpSLP::vectorizeTree(TreeEntry *E, bool PostponedPHIs) {
return E->VectorizedValue;
}
if (L->getType() != R->getType()) {
- assert((MinBWs.contains(VL0->getOperand(0)) ||
- MinBWs.contains(VL0->getOperand(1))) &&
+ assert((MinBWs.contains(getOperandEntry(E, 0)) ||
+ MinBWs.contains(getOperandEntry(E, 1))) &&
"Expected item in MinBWs.");
L = Builder.CreateIntCast(L, VecTy, IsSigned);
R = Builder.CreateIntCast(R, VecTy, IsSigned);
@@ -11420,8 +11446,8 @@ Value *BoUpSLP::vectorizeTree(TreeEntry *E, bool PostponedPHIs) {
return E->VectorizedValue;
}
if (True->getType() != False->getType()) {
- assert((MinBWs.contains(VL0->getOperand(1)) ||
- MinBWs.contains(VL0->getOperand(2))) &&
+ assert((MinBWs.contains(getOperandEntry(E, 1)) ||
+ MinBWs.contains(getOperandEntry(E, 2))) &&
"Expected item in MinBWs.");
True = Builder.CreateIntCast(True, VecTy, IsSigned);
False = Builder.CreateIntCast(False, VecTy, IsSigned);
@@ -11488,8 +11514,8 @@ Value *BoUpSLP::vectorizeTree(TreeEntry *E, bool PostponedPHIs) {
return E->VectorizedValue;
}
if (LHS->getType() != RHS->getType()) {
- assert((MinBWs.contains(VL0->getOperand(0)) ||
- MinBWs.contains(VL0->getOperand(1))) &&
+ assert((MinBWs.contains(getOperandEntry(E, 0)) ||
+ MinBWs.contains(getOperandEntry(E, 1))) &&
"Expected item in MinBWs.");
LHS = Builder.CreateIntCast(LHS, VecTy, IsSigned);
RHS = Builder.CreateIntCast(RHS, VecTy, IsSigned);
@@ -11725,8 +11751,8 @@ Value *BoUpSLP::vectorizeTree(TreeEntry *E, bool PostponedPHIs) {
return E->VectorizedValue;
}
if (LHS && RHS && LHS->getType() != RHS->getType()) {
- assert((MinBWs.contains(VL0->getOperand(0)) ||
- MinBWs.contains(VL0->getOperand(1))) &&
+ assert((MinBWs.contains(getOperandEntry(E, 0)) ||
+ MinBWs.contains(getOperandEntry(E, 1))) &&
"Expected item in MinBWs.");
LHS = Builder.CreateIntCast(LHS, VecTy, IsSigned);
RHS = Builder.CreateIntCast(RHS, VecTy, IsSigned);
@@ -11962,7 +11988,7 @@ Value *BoUpSLP::vectorizeTree(
// to the larger type.
if (Scalar->getType() != Ex->getType())
return Builder.CreateIntCast(Ex, Scalar->getType(),
- MinBWs.find(Scalar)->second.second);
+ MinBWs.find(E)->second.second);
return Ex;
}
assert(isa<FixedVectorType>(Scalar->getType()) &&
@@ -12003,7 +12029,7 @@ Value *BoUpSLP::vectorizeTree(
if (!UsedInserts.insert(VU).second)
continue;
// Need to use original vector, if the root is truncated.
- auto BWIt = MinBWs.find(Scalar);
+ auto BWIt = MinBWs.find(E);
if (BWIt != MinBWs.end() && Vec->getType() != VU->getType()) {
auto VecIt = VectorCasts.find(Scalar);
if (VecIt == VectorCasts.end()) {
@@ -13081,15 +13107,13 @@ unsigned BoUpSLP::getVectorElementSize(Value *V) {
// Determine if a value V in a vectorizable expression Expr can be demoted to a
// smaller type with a truncation. We collect the values that will be demoted
// in ToDemote and additional roots that require investigating in Roots.
-bool BoUpSLP::collectValuesToDemote(Value *V,
- SmallVectorImpl<Value *> &ToDemote,
- SmallVectorImpl<Value *> &Roots,
- DenseSet<Value *> &Visited) const {
+bool BoUpSLP::collectValuesToDemote(
+ Value *V, SmallVectorImpl<Value *> &ToDemote,
+ DenseMap<Instruction *, SmallVector<unsigned>> &DemotedConsts,
+ SmallVectorImpl<Value *> &Roots, DenseSet<Value *> &Visited) const {
// We can always demote constants.
- if (isa<Constant>(V)) {
- ToDemote.push_back(V);
+ if (isa<Constant>(V))
return true;
- }
// If the value is not a vectorized instruction in the expression with only
// one use, it cannot be demoted.
@@ -13097,6 +13121,8 @@ bool BoUpSLP::collectValuesToDemote(Value *V,
if (!I || !I->hasOneUse() || !getTreeEntry(I) || !Visited.insert(I).second)
return false;
+ unsigned Start = 0;
+ unsigned End = I->getNumOperands();
switch (I->getOpcode()) {
// We can always demote truncations and extensions. Since truncations can
@@ -13118,16 +13144,21 @@ bool BoUpSLP::collectValuesToDemote(Value *V,
case Instruction::And:
case Instruction::Or:
case Instruction::Xor:
- if (!collectValuesToDemote(I->getOperand(0), ToDemote, Roots, Visited) ||
- !collectValuesToDemote(I->getOperand(1), ToDemote, Roots, Visited))
+ if (!collectValuesToDemote(I->getOperand(0), ToDemote, DemotedConsts, Roots,
+ Visited) ||
+ !collectValuesToDemote(I->getOperand(1), ToDemote, DemotedConsts, Roots,
+ Visited))
return false;
break;
// We can demote selects if we can demote their true and false values.
case Instruction::Select: {
+ Start = 1;
SelectInst *SI = cast<SelectInst>(I);
- if (!collectValuesToDemote(SI->getTrueValue(), ToDemote, Roots, Visited) ||
- !collectValuesToDemote(SI->getFalseValue(), ToDemote, Roots, Visited))
+ if (!collectValuesToDemote(SI->getTrueValue(), ToDemote, DemotedConsts,
+ Roots, Visited) ||
+ !collectValuesToDemote(SI->getFalseValue(), ToDemote, DemotedConsts,
+ Roots, Visited))
return false;
break;
}
@@ -13137,7 +13168,8 @@ bool BoUpSLP::collectValuesToDemote(Value *V,
case Instruction::PHI: {
PHINode *PN = cast<PHINode>(I);
for (Value *IncValue : PN->incoming_values())
- if (!collectValuesToDemote(IncValue, ToDemote, Roots, Visited))
+ if (!collectValuesToDemote(IncValue, ToDemote, DemotedConsts, Roots,
+ Visited))
return false;
break;
}
@@ -13147,6 +13179,10 @@ bool BoUpSLP::collectValuesToDemote(Value *V,
return false;
}
+// Gather demoted constant operands.
+ for (unsigned Idx : seq<unsigned>(Start, End))
+ if (isa<Constant>(I->getOperand(Idx)))
+ DemotedConsts.try_emplace(I).first->getSecond().push_back(Idx);
// Record the value that we can demote.
ToDemote.push_back(V);
return true;
@@ -13172,10 +13208,11 @@ void BoUpSLP::computeMinimumValueSizes() {
// expression. Collect the values that can be demoted in ToDemote and
// additional roots that require investigating in Roots.
SmallVector<Value *, 32> ToDemote;
+ DenseMap<Instruction *, SmallVector<unsigned>> DemotedConsts;
SmallVector<Value *, 4> Roots;
for (auto *Root : TreeRoot) {
DenseSet<Value *> Visited;
- if (!collectValuesToDemote(Root, ToDemote, Roots, Visited))
+ if (!collectValuesToDemote(Root, ToDemote, DemotedConsts, Roots, Visited))
return;
}
@@ -13260,26 +13297,36 @@ void BoUpSLP::computeMinimumValueSizes() {
// modify.
while (!Roots.empty()) {
DenseSet<Value *> Visited;
- collectValuesToDemote(Roots.pop_back_val(), ToDemote, Roots, Visited);
+ collectValuesToDemote(Roots.pop_back_val(), ToDemote, DemotedConsts, Roots,
+ Visited);
}
// Finally, map the values we can demote to the maximum bit with we computed.
- DenseMap<const TreeEntry *, bool> Signendness;
for (auto *Scalar : ToDemote) {
- bool IsSigned = true;
- if (auto *TE = getTreeEntry(Scalar)) {
- auto It = Signendness.find(TE);
- if (It != Signendness.end()) {
- IsSigned = It->second;
- } else {
- IsSigned = any_of(TE->Scalars, [&](Value *R) {
- KnownBits Known = computeKnownBits(R, *DL);
- return !Known.isNonNegative();
- });
- Signendness.try_emplace(TE, IsSigned);
+ auto *TE = getTreeEntry(Scalar);
+ assert(TE && "Expected vectorized scalar.");
+ if (MinBWs.contains(TE))
+ continue;
+ bool IsSigned = any_of(TE->Scalars, [&](Value *R) {
+ KnownBits Known = computeKnownBits(R, *DL);
+ return !Known.isNonNegative();
+ });
+ MinBWs.try_emplace(TE, MaxBitWidth, IsSigned);
+ const auto *I = cast<Instruction>(Scalar);
+ auto DCIt = DemotedConsts.find(I);
+ if (DCIt != DemotedConsts.end()) {
+ for (unsigned Idx : DCIt->getSecond()) {
+ // Check that all instructions operands are demoted.
+ if (all_of(TE->Scalars, [&](Value *V) {
+ auto SIt = DemotedConsts.find(cast<Instruction>(V));
+ return SIt != DemotedConsts.end() &&
+ is_contained(SIt->getSecond(), Idx);
+ })) {
+ const TreeEntry *CTE = getOperandEntry(TE, Idx);
+ MinBWs.try_emplace(CTE, MaxBitWidth, IsSigned);
+ }
}
}
- MinBWs.try_emplace(Scalar, MaxBitWidth, IsSigned);
}
}
diff --git a/llvm/test/Transforms/SLPVectorizer/X86/minbitwidth-transformed-operand.ll b/llvm/test/Transforms/SLPVectorizer/X86/minbitwidth-transformed-operand.ll
index ac8dd659d4aefc9..94446b99514ba14 100644
--- a/llvm/test/Transforms/SLPVectorizer/X86/minbitwidth-transformed-operand.ll
+++ b/llvm/test/Transforms/SLPVectorizer/X86/minbitwidth-transformed-operand.ll
@@ -6,8 +6,8 @@ define void @test(i64 %d.promoted.i) {
; CHECK-SAME: i64 [[D_PROMOTED_I:%.*]]) {
; CHECK-NEXT: entry:
; CHECK-NEXT: [[TMP0:%.*]] = insertelement <2 x i64> <i64 poison, i64 0>, i64 [[D_PROMOTED_I]], i32 0
-; CHECK-NEXT: [[TMP1:%.*]] = and <2 x i64> zeroinitializer, [[TMP0]]
-; CHECK-NEXT: [[TMP2:%.*]] = trunc <2 x i64> [[TMP1]] to <2 x i1>
+; CHECK-NEXT: [[TMP1:%.*]] = trunc <2 x i64> [[TMP0]] to <2 x i1>
+; CHECK-NEXT: [[TMP2:%.*]] = and <2 x i1> zeroinitializer, [[TMP1]]
; CHECK-NEXT: [[TMP3:%.*]] = mul <2 x i1> [[TMP2]], zeroinitializer
; CHECK-NEXT: [[TMP4:%.*]] = or <2 x i1> [[TMP3]], zeroinitializer
; CHECK-NEXT: [[TMP5:%.*]] = or <2 x i1> [[TMP4]], zeroinitializer
|
|
✅ With the latest revision this PR passed the C/C++ code formatter. |
Currently, MinBWs map uses Value* as a key and stores mapping for each value to be demoted. It make is it hard to get the actual MinBWs value for the buildvector scalars(constants), since same constant might be used in different nodes with the different MinBWs values/decisions. Also, it consumes extra memory for the vectorized values/instructions from the same nodes. Better to map actual nodes. It fixes the bitwidth data fetching for buildvector scalars and improves memory consumption/analysis time for other instructions.
alexey-bataev
force-pushed
the
SLPMinBitWidthToTreeNode
branch
from
47a1591
to
18d0ff4
Compare
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
Currently, MinBWs map uses Value* as a key and stores mapping for each
value to be demoted. It make is it hard to get the actual MinBWs value
for the buildvector scalars(constants), since same constant might be
used in different nodes with the different MinBWs values/decisions.
Also, it consumes extra memory for the vectorized values/instructions
from the same nodes.
Better to map actual nodes. It fixes the bitwidth data fetching for
buildvector scalars and improves memory consumption/analysis time for
other instructions.