Lots of metrics

jakobbotsch · jakobbotsch · commit af98790a21e8 · 2024-05-29T20:30:53.000+02:00
diff --git a/src/coreclr/jit/inductionvariableopts.cpp b/src/coreclr/jit/inductionvariableopts.cpp
@@ -884,13 +884,15 @@ bool Compiler::optMakeLoopDownwardsCounted(ScalarEvolutionContext& scevContext,
         // With multiple exits we generally can only compute an upper bound on
         // the trip count.
         JITDUMP("  No; has multiple exits\n");
+        Metrics.TripCountMultipleExits++;
         return false;
     }
 
     BasicBlock* exiting = loop->ExitEdge(0)->getSourceBlock();
     if (!exiting->KindIs(BBJ_COND))
     {
         JITDUMP("  No; exit is not BBJ_COND\n");
+        Metrics.TripCountExitNotCond++;
         return false;
     }
 
@@ -905,6 +907,7 @@ bool Compiler::optMakeLoopDownwardsCounted(ScalarEvolutionContext& scevContext,
         // transform; otherwise we could. TODO-CQ: Make this determination and
         // extract side effects from the jtrue to make this work.
         JITDUMP("  No; exit node has side effects\n");
+        Metrics.TripCountExitSideEffects++;
         return false;
     }
 
@@ -914,6 +917,7 @@ bool Compiler::optMakeLoopDownwardsCounted(ScalarEvolutionContext& scevContext,
         (cond->gtGetOp1()->IsIntegralConst(0) || cond->gtGetOp2()->IsIntegralConst(0)))
     {
         JITDUMP("  No; operand of condition [%06u] is already 0\n", dspTreeID(cond));
+        Metrics.TripCountExitAlreadyHas0++;
         return false;
     }
 
@@ -970,18 +974,21 @@ bool Compiler::optMakeLoopDownwardsCounted(ScalarEvolutionContext& scevContext,
             if (!rootNode->OperIsLocalStore())
             {
                 // Cannot reason about this use of the local, cannot remove
+                Metrics.TripCountNonStoreUse++;
                 return false;
             }
 
             if (rootNode->AsLclVarCommon()->GetLclNum() != candidateLclNum)
             {
                 // Used to compute a value stored to some other local, cannot remove
+                Metrics.TripCountStoredFrom++;
                 return false;
             }
 
             if ((rootNode->AsLclVarCommon()->Data()->gtFlags & GTF_SIDE_EFFECT) != 0)
             {
                 // May be used inside the data node for something that has side effects, cannot remove
+                Metrics.TripCountStoreMayHaveSideEffect++;
                 return false;
             }
 
@@ -1007,6 +1014,7 @@ bool Compiler::optMakeLoopDownwardsCounted(ScalarEvolutionContext& scevContext,
 
     if (checkProfitability && (removableLocals.Height() <= 0))
     {
+        Metrics.TripCountNoRemovableLocals++;
         JITDUMP("  Found no potentially removable locals when making this loop downwards counted\n");
         return false;
     }
@@ -1031,6 +1039,7 @@ bool Compiler::optMakeLoopDownwardsCounted(ScalarEvolutionContext& scevContext,
             {
                 JITDUMP("  No; exiting block " FMT_BB " is not an ancestor of backedge source " FMT_BB "\n",
                         exiting->bbNum, backedge->getSourceBlock()->bbNum);
+                Metrics.TripCountBackedgesNotDominated++;
                 return false;
             }
 
@@ -1043,6 +1052,7 @@ bool Compiler::optMakeLoopDownwardsCounted(ScalarEvolutionContext& scevContext,
             {
                 JITDUMP("  No; exiting block " FMT_BB " does not dominate backedge source " FMT_BB "\n", exiting->bbNum,
                         backedge->getSourceBlock()->bbNum);
+                Metrics.TripCountBackedgesNotDominated++;
                 return false;
             }
         }
@@ -1055,6 +1065,7 @@ bool Compiler::optMakeLoopDownwardsCounted(ScalarEvolutionContext& scevContext,
     if (tripCount == nullptr)
     {
         JITDUMP("  Could not compute trip count -- not a counted loop\n");
+        Metrics.TripCountCouldNotCompute++;
         return false;
     }
 
@@ -1070,6 +1081,7 @@ bool Compiler::optMakeLoopDownwardsCounted(ScalarEvolutionContext& scevContext,
     if (decCountNode == nullptr)
     {
         JITDUMP("  Could not materialize trip count into IR\n");
+        Metrics.TripCountCouldNotMaterialize++;
         return false;
     }
 
diff --git a/src/coreclr/jit/jitmetadatalist.h b/src/coreclr/jit/jitmetadatalist.h
@@ -71,6 +71,26 @@ JITMETADATAMETRIC(ProfileInconsistentInlineeScale,       int,              0)
 JITMETADATAMETRIC(ProfileInconsistentInlinee,            int,              0)
 JITMETADATAMETRIC(ProfileInconsistentNoReturnInlinee,    int,              0)
 JITMETADATAMETRIC(ProfileInconsistentMayThrowInlinee,    int,              0)
+JITMETADATAMETRIC(TripCountMultipleExits,             int,              0)
+JITMETADATAMETRIC(TripCountExitNotCond,             int,              0)
+JITMETADATAMETRIC(TripCountExitSideEffects,             int,              0)
+JITMETADATAMETRIC(TripCountExitAlreadyHas0,             int,              0)
+JITMETADATAMETRIC(TripCountNonStoreUse,             int,              0)
+JITMETADATAMETRIC(TripCountStoredFrom,             int,              0)
+JITMETADATAMETRIC(TripCountStoreMayHaveSideEffect,             int,              0)
+JITMETADATAMETRIC(TripCountNoRemovableLocals,             int,              0)
+JITMETADATAMETRIC(TripCountBackedgesNotDominated,             int,              0)
+JITMETADATAMETRIC(TripCountCouldNotCompute,             int,              0)
+JITMETADATAMETRIC(TripCountCouldNotMaterialize,             int,              0)
+JITMETADATAMETRIC(TripCountUnsupportedCondOper,             int,              0)
+JITMETADATAMETRIC(TripCountNotIntegral,             int,              0)
+JITMETADATAMETRIC(TripCountCouldNotAnalyzeOperands,             int,              0)
+JITMETADATAMETRIC(TripCountGCOperand,             int,              0)
+JITMETADATAMETRIC(TripCountNoAddRec,             int,              0)
+JITMETADATAMETRIC(TripCountOperandVarianceMatch,             int,              0)
+JITMETADATAMETRIC(TripCountOverflowBeforeExit,             int,              0)
+JITMETADATAMETRIC(TripCountCouldNotProveLowerBound,             int,              0)
+JITMETADATAMETRIC(TripCountStepNotOne,             int,              0)
 
 #undef JITMETADATA
 #undef JITMETADATAINFO
diff --git a/src/coreclr/jit/scev.cpp b/src/coreclr/jit/scev.cpp
@@ -1563,11 +1563,13 @@ Scev* ScalarEvolutionContext::ComputeExitNotTakenCount(BasicBlock* exiting)
     if (!cond->OperIs(GT_LT, GT_LE, GT_GT, GT_GE))
     {
         // TODO-CQ: We can handle EQ/NE with divisibility checks.
+        m_comp->Metrics.TripCountUnsupportedCondOper++;
         return nullptr;
     }
 
     if (!varTypeIsIntegralOrI(cond->gtGetOp1()))
     {
+        m_comp->Metrics.TripCountNotIntegral++;
         return nullptr;
     }
 
@@ -1576,12 +1578,14 @@ Scev* ScalarEvolutionContext::ComputeExitNotTakenCount(BasicBlock* exiting)
 
     if ((op1 == nullptr) || (op2 == nullptr))
     {
+        m_comp->Metrics.TripCountCouldNotAnalyzeOperands++;
         return nullptr;
     }
 
     if (varTypeIsGC(op1->Type) || varTypeIsGC(op2->Type))
     {
         // TODO-CQ: Add SUB operator
+        m_comp->Metrics.TripCountGCOperand++;
         return nullptr;
     }
 
@@ -1600,6 +1604,7 @@ Scev* ScalarEvolutionContext::ComputeExitNotTakenCount(BasicBlock* exiting)
     {
         // If both are invariant we could still handle some cases here (it will
         // be 0 or infinite). Probably uncommon.
+        m_comp->Metrics.TripCountNoAddRec++;
         return nullptr;
     }
 
@@ -1610,6 +1615,7 @@ Scev* ScalarEvolutionContext::ComputeExitNotTakenCount(BasicBlock* exiting)
     {
         // Both variant. Here we could also prove also try to prove some cases,
         // but again this is expected to be uncommon.
+        m_comp->Metrics.TripCountOperandVarianceMatch++;
         return nullptr;
     }
 
@@ -1654,6 +1660,7 @@ Scev* ScalarEvolutionContext::ComputeExitNotTakenCount(BasicBlock* exiting)
     if (MayOverflowBeforeExit((ScevAddRec*)lhs, rhs, exitOpVNF))
     {
         JITDUMP("  May overflow, cannot determine trip count\n");
+        m_comp->Metrics.TripCountOverflowBeforeExit++;
         return nullptr;
     }
 
@@ -1732,6 +1739,7 @@ Scev* ScalarEvolutionContext::ComputeExitNotTakenCount(BasicBlock* exiting)
 
     if (result != RelopEvaluationResult::True)
     {
+        m_comp->Metrics.TripCountCouldNotProveLowerBound++;
         return nullptr;
     }
 
@@ -1740,6 +1748,7 @@ Scev* ScalarEvolutionContext::ComputeExitNotTakenCount(BasicBlock* exiting)
     if (!divisor->GetConstantValue(m_comp, &divisorVal) || ((divisorVal != 1) && (divisorVal != -1)))
     {
         // TODO-CQ: Enable. Likely need to add a division operator to SCEV.
+        m_comp->Metrics.TripCountStepNotOne++;
         return nullptr;
     }
 

Original file line number	Diff line number	Diff line change
`@@ -884,13 +884,15 @@ bool Compiler::optMakeLoopDownwardsCounted(ScalarEvolutionContext& scevContext,`
`884`	`884`	`// With multiple exits we generally can only compute an upper bound on`
`885`	`885`	`// the trip count.`
`886`	`886`	`JITDUMP(" No; has multiple exits\n");`
	`887`	`+ Metrics.TripCountMultipleExits++;`
`887`	`888`	`return false;`
`888`	`889`	`}`
`889`	`890`
`890`	`891`	`BasicBlock* exiting = loop->ExitEdge(0)->getSourceBlock();`
`891`	`892`	`if (!exiting->KindIs(BBJ_COND))`
`892`	`893`	`{`
`893`	`894`	`JITDUMP(" No; exit is not BBJ_COND\n");`
	`895`	`+ Metrics.TripCountExitNotCond++;`
`894`	`896`	`return false;`
`895`	`897`	`}`
`896`	`898`
`@@ -905,6 +907,7 @@ bool Compiler::optMakeLoopDownwardsCounted(ScalarEvolutionContext& scevContext,`
`905`	`907`	`// transform; otherwise we could. TODO-CQ: Make this determination and`
`906`	`908`	`// extract side effects from the jtrue to make this work.`
`907`	`909`	`JITDUMP(" No; exit node has side effects\n");`
	`910`	`+ Metrics.TripCountExitSideEffects++;`
`908`	`911`	`return false;`
`909`	`912`	`}`
`910`	`913`
`@@ -914,6 +917,7 @@ bool Compiler::optMakeLoopDownwardsCounted(ScalarEvolutionContext& scevContext,`
`914`	`917`	`(cond->gtGetOp1()->IsIntegralConst(0) \|\| cond->gtGetOp2()->IsIntegralConst(0)))`
`915`	`918`	`{`
`916`	`919`	`JITDUMP(" No; operand of condition [%06u] is already 0\n", dspTreeID(cond));`
	`920`	`+ Metrics.TripCountExitAlreadyHas0++;`
`917`	`921`	`return false;`
`918`	`922`	`}`
`919`	`923`
`@@ -970,18 +974,21 @@ bool Compiler::optMakeLoopDownwardsCounted(ScalarEvolutionContext& scevContext,`
`970`	`974`	`if (!rootNode->OperIsLocalStore())`
`971`	`975`	`{`
`972`	`976`	`// Cannot reason about this use of the local, cannot remove`
	`977`	`+ Metrics.TripCountNonStoreUse++;`
`973`	`978`	`return false;`
`974`	`979`	`}`
`975`	`980`
`976`	`981`	`if (rootNode->AsLclVarCommon()->GetLclNum() != candidateLclNum)`
`977`	`982`	`{`
`978`	`983`	`// Used to compute a value stored to some other local, cannot remove`
	`984`	`+ Metrics.TripCountStoredFrom++;`
`979`	`985`	`return false;`
`980`	`986`	`}`
`981`	`987`
`982`	`988`	`if ((rootNode->AsLclVarCommon()->Data()->gtFlags & GTF_SIDE_EFFECT) != 0)`
`983`	`989`	`{`
`984`	`990`	`// May be used inside the data node for something that has side effects, cannot remove`
	`991`	`+ Metrics.TripCountStoreMayHaveSideEffect++;`
`985`	`992`	`return false;`
`986`	`993`	`}`
`987`	`994`
`@@ -1007,6 +1014,7 @@ bool Compiler::optMakeLoopDownwardsCounted(ScalarEvolutionContext& scevContext,`
`1007`	`1014`
`1008`	`1015`	`if (checkProfitability && (removableLocals.Height() <= 0))`
`1009`	`1016`	`{`
	`1017`	`+ Metrics.TripCountNoRemovableLocals++;`
`1010`	`1018`	`JITDUMP(" Found no potentially removable locals when making this loop downwards counted\n");`
`1011`	`1019`	`return false;`
`1012`	`1020`	`}`
`@@ -1031,6 +1039,7 @@ bool Compiler::optMakeLoopDownwardsCounted(ScalarEvolutionContext& scevContext,`
`1031`	`1039`	`{`
`1032`	`1040`	`JITDUMP(" No; exiting block " FMT_BB " is not an ancestor of backedge source " FMT_BB "\n",`
`1033`	`1041`	`exiting->bbNum, backedge->getSourceBlock()->bbNum);`
	`1042`	`+ Metrics.TripCountBackedgesNotDominated++;`
`1034`	`1043`	`return false;`
`1035`	`1044`	`}`
`1036`	`1045`
`@@ -1043,6 +1052,7 @@ bool Compiler::optMakeLoopDownwardsCounted(ScalarEvolutionContext& scevContext,`
`1043`	`1052`	`{`
`1044`	`1053`	`JITDUMP(" No; exiting block " FMT_BB " does not dominate backedge source " FMT_BB "\n", exiting->bbNum,`
`1045`	`1054`	`backedge->getSourceBlock()->bbNum);`
	`1055`	`+ Metrics.TripCountBackedgesNotDominated++;`
`1046`	`1056`	`return false;`
`1047`	`1057`	`}`
`1048`	`1058`	`}`
`@@ -1055,6 +1065,7 @@ bool Compiler::optMakeLoopDownwardsCounted(ScalarEvolutionContext& scevContext,`
`1055`	`1065`	`if (tripCount == nullptr)`
`1056`	`1066`	`{`
`1057`	`1067`	`JITDUMP(" Could not compute trip count -- not a counted loop\n");`
	`1068`	`+ Metrics.TripCountCouldNotCompute++;`
`1058`	`1069`	`return false;`
`1059`	`1070`	`}`
`1060`	`1071`
`@@ -1070,6 +1081,7 @@ bool Compiler::optMakeLoopDownwardsCounted(ScalarEvolutionContext& scevContext,`
`1070`	`1081`	`if (decCountNode == nullptr)`
`1071`	`1082`	`{`
`1072`	`1083`	`JITDUMP(" Could not materialize trip count into IR\n");`
	`1084`	`+ Metrics.TripCountCouldNotMaterialize++;`
`1073`	`1085`	`return false;`
`1074`	`1086`	`}`
`1075`	`1087`
Original file line number	Diff line number	Diff line change
`@@ -1563,11 +1563,13 @@ Scev* ScalarEvolutionContext::ComputeExitNotTakenCount(BasicBlock* exiting)`
`1563`	`1563`	`if (!cond->OperIs(GT_LT, GT_LE, GT_GT, GT_GE))`
`1564`	`1564`	`{`
`1565`	`1565`	`// TODO-CQ: We can handle EQ/NE with divisibility checks.`
	`1566`	`+ m_comp->Metrics.TripCountUnsupportedCondOper++;`
`1566`	`1567`	`return nullptr;`
`1567`	`1568`	`}`
`1568`	`1569`
`1569`	`1570`	`if (!varTypeIsIntegralOrI(cond->gtGetOp1()))`
`1570`	`1571`	`{`
	`1572`	`+ m_comp->Metrics.TripCountNotIntegral++;`
`1571`	`1573`	`return nullptr;`
`1572`	`1574`	`}`
`1573`	`1575`
`@@ -1576,12 +1578,14 @@ Scev* ScalarEvolutionContext::ComputeExitNotTakenCount(BasicBlock* exiting)`
`1576`	`1578`
`1577`	`1579`	`if ((op1 == nullptr) \|\| (op2 == nullptr))`
`1578`	`1580`	`{`
	`1581`	`+ m_comp->Metrics.TripCountCouldNotAnalyzeOperands++;`
`1579`	`1582`	`return nullptr;`
`1580`	`1583`	`}`
`1581`	`1584`
`1582`	`1585`	`if (varTypeIsGC(op1->Type) \|\| varTypeIsGC(op2->Type))`
`1583`	`1586`	`{`
`1584`	`1587`	`// TODO-CQ: Add SUB operator`
	`1588`	`+ m_comp->Metrics.TripCountGCOperand++;`
`1585`	`1589`	`return nullptr;`
`1586`	`1590`	`}`
`1587`	`1591`
`@@ -1600,6 +1604,7 @@ Scev* ScalarEvolutionContext::ComputeExitNotTakenCount(BasicBlock* exiting)`
`1600`	`1604`	`{`
`1601`	`1605`	`// If both are invariant we could still handle some cases here (it will`
`1602`	`1606`	`// be 0 or infinite). Probably uncommon.`
	`1607`	`+ m_comp->Metrics.TripCountNoAddRec++;`
`1603`	`1608`	`return nullptr;`
`1604`	`1609`	`}`
`1605`	`1610`
`@@ -1610,6 +1615,7 @@ Scev* ScalarEvolutionContext::ComputeExitNotTakenCount(BasicBlock* exiting)`
`1610`	`1615`	`{`
`1611`	`1616`	`// Both variant. Here we could also prove also try to prove some cases,`
`1612`	`1617`	`// but again this is expected to be uncommon.`
	`1618`	`+ m_comp->Metrics.TripCountOperandVarianceMatch++;`
`1613`	`1619`	`return nullptr;`
`1614`	`1620`	`}`
`1615`	`1621`
`@@ -1654,6 +1660,7 @@ Scev* ScalarEvolutionContext::ComputeExitNotTakenCount(BasicBlock* exiting)`
`1654`	`1660`	`if (MayOverflowBeforeExit((ScevAddRec*)lhs, rhs, exitOpVNF))`
`1655`	`1661`	`{`
`1656`	`1662`	`JITDUMP(" May overflow, cannot determine trip count\n");`
	`1663`	`+ m_comp->Metrics.TripCountOverflowBeforeExit++;`
`1657`	`1664`	`return nullptr;`
`1658`	`1665`	`}`
`1659`	`1666`
`@@ -1732,6 +1739,7 @@ Scev* ScalarEvolutionContext::ComputeExitNotTakenCount(BasicBlock* exiting)`
`1732`	`1739`
`1733`	`1740`	`if (result != RelopEvaluationResult::True)`
`1734`	`1741`	`{`
	`1742`	`+ m_comp->Metrics.TripCountCouldNotProveLowerBound++;`
`1735`	`1743`	`return nullptr;`
`1736`	`1744`	`}`
`1737`	`1745`
`@@ -1740,6 +1748,7 @@ Scev* ScalarEvolutionContext::ComputeExitNotTakenCount(BasicBlock* exiting)`
`1740`	`1748`	`if (!divisor->GetConstantValue(m_comp, &divisorVal) \|\| ((divisorVal != 1) && (divisorVal != -1)))`
`1741`	`1749`	`{`
`1742`	`1750`	`// TODO-CQ: Enable. Likely need to add a division operator to SCEV.`
	`1751`	`+ m_comp->Metrics.TripCountStepNotOne++;`
`1743`	`1752`	`return nullptr;`
`1744`	`1753`	`}`
`1745`	`1754`