[release/11.0-preview2] Revert "Increase number of assertions (GlobalAP) + VN cache (#124132)" (#124955)

Backport of #124928 to release/11.0-preview2

/cc @akoeplinger @AndyAyersMS

## Customer Impact

- [ ] Customer reported
- [x] Found internally

This was causing excessive memory allocation during jitting (see
dotnet/dotnet#4933).
## Regression

- [X] Yes
- [ ] No

Caused by:
92741be

## Testing

Manual testing.

## Risk

Low. Reverts an earlier change.

[High/Medium/Low. Justify the indication by mentioning how risks were
measured and addressed.]

**IMPORTANT**: If this backport is for a servicing release, please
verify that:

- For .NET 8 and .NET 9: The PR target branch is `release/X.0-staging`,
not `release/X.0`.
- For .NET 10+: The PR target branch is `release/X.0` (no `-staging`
suffix).

## Package authoring no longer needed in .NET 9

**IMPORTANT**: Starting with .NET 9, you no longer need to edit a NuGet
package's csproj to enable building and bump the version.
Keep in mind that we still need package authoring in .NET 8 and older
versions.

Co-authored-by: Andy Ayers <andya@microsoft.com>

Author: github-actions[bot]

src/coreclr/jit/assertionprop.cpp

@@ -725,14 +725,16 @@ void Compiler::optAssertionInit(bool isLocalProp)
         optLocalAssertionProp           = false;
         optCrossBlockLocalAssertionProp = false;
 
-        // Heuristic for sizing the assertion table.
+        // Use a function countFunc to determine a proper maximum assertion count for the
+        // method being compiled. The function is linear to the IL size for small and
+        // moderate methods. For large methods, considering throughput impact, we track no
+        // more than 64 assertions.
+        // Note this tracks at most only 256 assertions.
         //
-        // The weighting of basicBlocks vs locals reflects their relative contribution observed empirically.
-        // Validated against 1,115,046 compiled methods:
-        //   - 94.6% of methods stay at the floor of 64 (only 1.9% actually need more).
-        //   - Underpredicts for 481 methods (0.043%), with a worst-case deficit of 127.
-        //   - Only 0.4% of methods hit the 256 cap.
-        optMaxAssertionCount = (AssertionIndex)max(64, min(256, (int)(lvaTrackedCount + 3 * fgBBcount + 48) >> 2));
+        static const AssertionIndex countFunc[] = {64, 128, 256, 128, 64};
+        static const unsigned       upperBound  = ArrLen(countFunc) - 1;
+        const unsigned              codeSize    = info.compILCodeSize / 512;
+        optMaxAssertionCount                    = countFunc[min(upperBound, codeSize)];
 
         optComplementaryAssertionMap = new (this, CMK_AssertionProp)
             AssertionIndex[optMaxAssertionCount + 1](); // zero-inited (NO_ASSERTION_INDEX)
@@ -1350,8 +1352,6 @@ bool Compiler::optIsTreeKnownIntValue(bool vnBased, GenTree* tree, ssize_t* pCon
  */
 AssertionIndex Compiler::optAddAssertion(const AssertionDsc& newAssertion)
 {
-    bool canAddNewAssertions = optAssertionCount < optMaxAssertionCount;
-
     // See if we already have this assertion in the table.
     //
     // For local assertion prop we can speed things up by checking the dep vector.
@@ -1378,40 +1378,21 @@ AssertionIndex Compiler::optAddAssertion(const AssertionDsc& newAssertion)
     }
     else
     {
-        bool mayHaveDuplicates =
-            optAssertionHasAssertionsForVN(newAssertion.GetOp1().GetVN(), /* addIfNotFound */ canAddNewAssertions);
-        // We need to register op2.vn too, even if we know for sure there are no duplicates
-        if (newAssertion.GetOp2().KindIs(O2K_CHECKED_BOUND_ADD_CNS))
-        {
-            mayHaveDuplicates |= optAssertionHasAssertionsForVN(newAssertion.GetOp2().GetCheckedBound(),
-                                                                /* addIfNotFound */ canAddNewAssertions);
-
-            // Additionally, check for the pattern of "VN + const == checkedBndVN" and register "VN" as well.
-            ValueNum addOpVN;
-            if (vnStore->IsVNBinFuncWithConst<int>(newAssertion.GetOp1().GetVN(), VNF_ADD, &addOpVN, nullptr))
-            {
-                mayHaveDuplicates |= optAssertionHasAssertionsForVN(addOpVN, /* addIfNotFound */ canAddNewAssertions);
-            }
-        }
-
-        if (mayHaveDuplicates)
+        // For global prop we search the entire table.
+        //
+        // Check if exists already, so we can skip adding new one. Search backwards.
+        for (AssertionIndex index = optAssertionCount; index >= 1; index--)
         {
-            // For global prop we search the entire table.
-            //
-            // Check if exists already, so we can skip adding new one. Search backwards.
-            for (AssertionIndex index = optAssertionCount; index >= 1; index--)
+            const AssertionDsc& curAssertion = optGetAssertion(index);
+            if (curAssertion.Equals(newAssertion, /* vnBased */ true))
             {
-                const AssertionDsc& curAssertion = optGetAssertion(index);
-                if (curAssertion.Equals(newAssertion, /* vnBased */ true))
-                {
-                    return index;
-                }
+                return index;
             }
         }
     }
 
     // Check if we are within max count.
-    if (!canAddNewAssertions)
+    if (optAssertionCount >= optMaxAssertionCount)
     {
         optAssertionOverflow++;
         return NO_ASSERTION_INDEX;
@@ -1458,49 +1439,6 @@ AssertionIndex Compiler::optAddAssertion(const AssertionDsc& newAssertion)
     return optAssertionCount;
 }
 
-//------------------------------------------------------------------------
-// optAssertionHasAssertionsForVN: Check if we already have assertions for the given VN.
-//    If "addIfNotFound" is true, add the VN to the map if it's not already there.
-//
-// Arguments:
-//    vn            - the VN to check for
-//    addIfNotFound - whether to add the VN to the map if it's not found
-//
-// Return Value:
-//    true if we already have assertions for the given VN, false otherwise.
-//
-bool Compiler::optAssertionHasAssertionsForVN(ValueNum vn, bool addIfNotFound)
-{
-    assert(!optLocalAssertionProp);
-    if (vn == ValueNumStore::NoVN)
-    {
-        assert(!addIfNotFound);
-        return false;
-    }
-
-    if (addIfNotFound)
-    {
-        // Lazy initialize the map when we first need to add to it
-        if (optAssertionVNsMap == nullptr)
-        {
-            optAssertionVNsMap = new (this, CMK_AssertionProp) VNSet(getAllocator(CMK_AssertionProp));
-        }
-
-        // Avoid double lookup by using the return value of LookupPointerOrAdd to
-        // determine whether the VN was already in the map.
-        bool* pValue = optAssertionVNsMap->LookupPointerOrAdd(vn, false);
-        if (!*pValue)
-        {
-            *pValue = true;
-            return false;
-        }
-        return true;
-    }
-
-    // Otherwise just do a normal lookup
-    return (optAssertionVNsMap != nullptr) && optAssertionVNsMap->Lookup(vn);
-}
-
 #ifdef DEBUG
 void Compiler::optDebugCheckAssertion(const AssertionDsc& assertion) const
 {
@@ -3353,18 +3291,12 @@ GenTree* Compiler::optAssertionProp_LclVar(ASSERT_VALARG_TP assertions, GenTreeL
     // For local assertion prop we can filter the assertion set down.
     //
     const unsigned lclNum = tree->GetLclNum();
-    ValueNum       treeVN = optConservativeNormalVN(tree);
 
     ASSERT_TP filteredAssertions = assertions;
     if (optLocalAssertionProp)
     {
         filteredAssertions = BitVecOps::Intersection(apTraits, GetAssertionDep(lclNum), filteredAssertions);
     }
-    else if (!optAssertionHasAssertionsForVN(treeVN))
-    {
-        // There are no assertions for this VN
-        return nullptr;
-    }
 
     BitVecOps::Iter iter(apTraits, filteredAssertions);
     unsigned        index = 0;
@@ -3426,7 +3358,7 @@ GenTree* Compiler::optAssertionProp_LclVar(ASSERT_VALARG_TP assertions, GenTreeL
         else
         {
             // Check VN in Global Assertion Prop
-            if (curAssertion.GetOp1().GetVN() == treeVN)
+            if (curAssertion.GetOp1().GetVN() == vnStore->VNConservativeNormalValue(tree->gtVNPair))
             {
                 return optConstantAssertionProp(curAssertion, tree, stmt DEBUGARG(assertionIndex));
             }
@@ -4740,7 +4672,7 @@ bool Compiler::optAssertionVNIsNonNull(ValueNum vn, ASSERT_VALARG_TP assertions)
         return true;
     }
 
-    if (!BitVecOps::MayBeUninit(assertions) && optAssertionHasAssertionsForVN(vn))
+    if (!BitVecOps::MayBeUninit(assertions))
     {
         BitVecOps::Iter iter(apTraits, assertions);
         unsigned        index = 0;

src/coreclr/jit/compiler.h

@@ -8432,8 +8432,7 @@ class Compiler
     JitExpandArray<ASSERT_TP>* optAssertionDep = nullptr; // table that holds dependent assertions (assertions
                                                           // using the value of a local var) for each local var
     AssertionDsc*  optAssertionTabPrivate;                // table that holds info about assertions
-    VNSet*         optAssertionVNsMap = nullptr;
-    AssertionIndex optAssertionCount  = 0; // total number of assertions in the assertion table
+    AssertionIndex optAssertionCount = 0;                 // total number of assertions in the assertion table
     AssertionIndex optMaxAssertionCount;
     bool           optCrossBlockLocalAssertionProp;
     unsigned       optAssertionOverflow;
@@ -8562,7 +8561,6 @@ class Compiler
 
     bool optCreateJumpTableImpliedAssertions(BasicBlock* switchBb);
 
-    bool optAssertionHasAssertionsForVN(ValueNum vn, bool addIfNotFound = false);
 #ifdef DEBUG
     void optPrintAssertion(const AssertionDsc& newAssertion, AssertionIndex assertionIndex = 0);
     void optPrintAssertionIndex(AssertionIndex index);

src/coreclr/jit/rangecheck.cpp

@@ -977,7 +977,7 @@ void RangeCheck::MergeEdgeAssertions(Compiler*        comp,
         return;
     }
 
-    if (!comp->optAssertionHasAssertionsForVN(normalLclVN))
+    if (normalLclVN == ValueNumStore::NoVN)
     {
         return;
     }