Float weights

src/coreclr/src/jit/assertionprop.cpp

@@ -143,7 +143,8 @@ void Compiler::optAddCopies()
         BlockSet paramImportantUseDom(BlockSetOps::MakeFull(this));
 
         // This will be threshold for determining heavier-than-average uses
-        unsigned paramAvgWtdRefDiv2 = (varDsc->lvRefCntWtd() + varDsc->lvRefCnt() / 2) / (varDsc->lvRefCnt() * 2);
+        BasicBlock::weight_t paramAvgWtdRefDiv2 =
+            (varDsc->lvRefCntWtd() + varDsc->lvRefCnt() / 2) / (varDsc->lvRefCnt() * 2);
 
         bool paramFoundImportantUse = false;
 
@@ -306,9 +307,9 @@ void Compiler::optAddCopies()
             /* dominates all the uses of the local variable         */
 
             /* Our default is to use the first block */
-            BasicBlock* bestBlock  = fgFirstBB;
-            unsigned    bestWeight = bestBlock->getBBWeight(this);
-            BasicBlock* block      = bestBlock;
+            BasicBlock*          bestBlock  = fgFirstBB;
+            BasicBlock::weight_t bestWeight = bestBlock->getBBWeight(this);
+            BasicBlock*          block      = bestBlock;
 
 #ifdef DEBUG
             if (verbose)

src/coreclr/src/jit/block.h

@@ -514,16 +514,17 @@ struct BasicBlock : private LIR::Range
     const char* dspToString(int blockNumPadding = 0);
 #endif // DEBUG
 
-    typedef unsigned weight_t; // Type used to hold block and edge weights
-                               // Note that for CLR v2.0 and earlier our
-                               // block weights were stored using unsigned shorts
-
-#define BB_UNITY_WEIGHT 100 // how much a normal execute once block weights
-#define BB_LOOP_WEIGHT 8    // how much more loops are weighted
-#define BB_ZERO_WEIGHT 0
-#define BB_MAX_WEIGHT UINT32_MAX // we're using an 'unsigned' for the weight
-#define BB_VERY_HOT_WEIGHT 256   // how many average hits a BB has (per BBT scenario run) for this block
-                                 // to be considered as very hot
+    // Type used to hold block and edge weights
+    typedef float weight_t;
+
+#define BB_UNITY_WEIGHT 100.0f       // how much a normal execute once block weights
+#define BB_UNITY_WEIGHT_UNSIGNED 100 // how much a normal execute once block weights
+#define BB_LOOP_WEIGHT 8.0f          // how much more loops are weighted
+#define BB_ZERO_WEIGHT 0.0f
+#define BB_HOT_WEIGHT 1000000.0f
+#define BB_MAX_WEIGHT FLT_MAX     // maximum finite weight  -- needs rethinking.
+#define BB_VERY_HOT_WEIGHT 256.0f // how many average hits a BB has (per BBT scenario run) for this block
+                                  // to be considered as very hot
 
     weight_t bbWeight; // The dynamic execution weight of this block
 
@@ -551,7 +552,7 @@ struct BasicBlock : private LIR::Range
     }
 
     // setBBProfileWeight -- Set the profile-derived weight for a basic block
-    void setBBProfileWeight(unsigned weight)
+    void setBBProfileWeight(weight_t weight)
     {
         this->bbFlags |= BBF_PROF_WEIGHT;
         this->bbWeight = weight;

src/coreclr/src/jit/codegencommon.cpp

@@ -2203,7 +2203,7 @@ void CodeGen::genGenerateMachineCode()
 
         if (compiler->fgHaveProfileData())
         {
-            printf("; with IBC profile data, edge weights are %s, and fgCalledCount is %u\n",
+            printf("; with IBC profile data, edge weights are %s, and fgCalledCount is %.0f\n",
                    compiler->fgHaveValidEdgeWeights ? "valid" : "invalid", compiler->fgCalledCount);
         }
 

src/coreclr/src/jit/compiler.h

@@ -1,4 +1,5 @@
 // Licensed to the .NET Foundation under one or more agreements.
+// Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
 /*XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
@@ -5526,7 +5527,7 @@ class Compiler
 
     bool fgHaveProfileData();
     void fgComputeProfileScale();
-    bool fgGetProfileWeightForBasicBlock(IL_OFFSET offset, unsigned* weight);
+    bool fgGetProfileWeightForBasicBlock(IL_OFFSET offset, BasicBlock::weight_t* weight);
     void fgInstrumentMethod();
 
 public:
@@ -5541,7 +5542,7 @@ class Compiler
     //                      or BB_UNITY_WEIGHT when we aren't using profile data.
     unsigned fgProfileRunsCount()
     {
-        return fgIsUsingProfileWeights() ? fgNumProfileRuns : BB_UNITY_WEIGHT;
+        return fgIsUsingProfileWeights() ? fgNumProfileRuns : BB_UNITY_WEIGHT_UNSIGNED;
     }
 
 //-------- Insert a statement at the start or end of a basic block --------
@@ -6080,7 +6081,7 @@ class Compiler
     // non-loop predecessors other than the head entry, create a new, empty block that goes (only) to the entry,
     // and redirects the preds of the entry to this new block.)  Sets the weight of the newly created block to
     // "ambientWeight".
-    void optEnsureUniqueHead(unsigned loopInd, unsigned ambientWeight);
+    void optEnsureUniqueHead(unsigned loopInd, BasicBlock::weight_t ambientWeight);
 
     void optUnrollLoops(); // Unrolls loops (needs to have cost info)
 
@@ -6485,8 +6486,8 @@ class Compiler
         unsigned short csdDefCount; // definition   count
         unsigned short csdUseCount; // use          count  (excluding the implicit uses at defs)
 
-        unsigned csdDefWtCnt; // weighted def count
-        unsigned csdUseWtCnt; // weighted use count  (excluding the implicit uses at defs)
+        BasicBlock::weight_t csdDefWtCnt; // weighted def count
+        BasicBlock::weight_t csdUseWtCnt; // weighted use count  (excluding the implicit uses at defs)
 
         GenTree*    csdTree;  // treenode containing the 1st occurrence
         Statement*  csdStmt;  // stmt containing the 1st occurrence
@@ -6599,13 +6600,13 @@ class Compiler
 #endif // FEATURE_VALNUM_CSE
 
 #if FEATURE_ANYCSE
-    bool     optDoCSE;             // True when we have found a duplicate CSE tree
-    bool     optValnumCSE_phase;   // True when we are executing the optValnumCSE_phase
-    unsigned optCSECandidateTotal; // Grand total of CSE candidates for both Lexical and ValNum
-    unsigned optCSECandidateCount; // Count of CSE's candidates, reset for Lexical and ValNum CSE's
-    unsigned optCSEstart;          // The first local variable number that is a CSE
-    unsigned optCSEcount;          // The total count of CSE's introduced.
-    unsigned optCSEweight;         // The weight of the current block when we are doing PerformCSE
+    bool                 optDoCSE;             // True when we have found a duplicate CSE tree
+    bool                 optValnumCSE_phase;   // True when we are executing the optValnumCSE_phase
+    unsigned             optCSECandidateTotal; // Grand total of CSE candidates for both Lexical and ValNum
+    unsigned             optCSECandidateCount; // Count of CSE's candidates, reset for Lexical and ValNum CSE's
+    unsigned             optCSEstart;          // The first local variable number that is a CSE
+    unsigned             optCSEcount;          // The total count of CSE's introduced.
+    BasicBlock::weight_t optCSEweight;         // The weight of the current block when we are doing PerformCSE
 
     bool optIsCSEcandidate(GenTree* tree);
 
@@ -7712,11 +7713,11 @@ class Compiler
         return codeGen->doDoubleAlign();
     }
     DWORD getCanDoubleAlign();
-    bool shouldDoubleAlign(unsigned refCntStk,
-                           unsigned refCntReg,
-                           unsigned refCntWtdReg,
-                           unsigned refCntStkParam,
-                           unsigned refCntWtdStkDbl);
+    bool shouldDoubleAlign(unsigned             refCntStk,
+                           unsigned             refCntReg,
+                           BasicBlock::weight_t refCntWtdReg,
+                           unsigned             refCntStkParam,
+                           BasicBlock::weight_t refCntWtdStkDbl);
 #endif // DOUBLE_ALIGN
 
     bool IsFullPtrRegMapRequired()

src/coreclr/src/jit/compiler.hpp

@@ -856,7 +856,7 @@ inline unsigned int genCSEnum2bit(unsigned index)
 
 #ifdef DEBUG
 const char* genES2str(BitVecTraits* traits, EXPSET_TP set);
-const char* refCntWtd2str(unsigned refCntWtd);
+const char* refCntWtd2str(BasicBlock::weight_t refCntWtd);
 #endif
 
 /*
@@ -1841,15 +1841,9 @@ inline void LclVarDsc::incRefCnts(BasicBlock::weight_t weight, Compiler* comp, R
                 weight *= 2;
             }
 
-            unsigned newWeight = lvRefCntWtd(state) + weight;
-            if (newWeight >= lvRefCntWtd(state))
-            { // lvRefCntWtd is an "unsigned".  Don't overflow it
-                setLvRefCntWtd(newWeight, state);
-            }
-            else
-            { // On overflow we assign UINT32_MAX
-                setLvRefCntWtd(UINT32_MAX, state);
-            }
+            BasicBlock::weight_t newWeight = lvRefCntWtd(state) + weight;
+            assert(newWeight >= lvRefCntWtd(state));
+            setLvRefCntWtd(newWeight, state);
         }
     }
 

src/coreclr/src/jit/decomposelongs.cpp

@@ -61,9 +61,7 @@ void DecomposeLongs::DecomposeBlock(BasicBlock* block)
 {
     assert(block == m_compiler->compCurBB); // compCurBB must already be set.
     assert(block->isEmpty() || block->IsLIR());
-
-    m_blockWeight = block->getBBWeight(m_compiler);
-    m_range       = &LIR::AsRange(block);
+    m_range = &LIR::AsRange(block);
     DecomposeRangeHelper();
 }
 
@@ -75,20 +73,17 @@ void DecomposeLongs::DecomposeBlock(BasicBlock* block)
 //
 // Arguments:
 //    compiler    - The compiler context.
-//    blockWeight - The weight of the block into which the range will be
-//                  inserted.
 //    range       - The range to decompose.
 //
 // Return Value:
 //    None.
 //
-void DecomposeLongs::DecomposeRange(Compiler* compiler, unsigned blockWeight, LIR::Range& range)
+void DecomposeLongs::DecomposeRange(Compiler* compiler, LIR::Range& range)
 {
     assert(compiler != nullptr);
 
     DecomposeLongs decomposer(compiler);
-    decomposer.m_blockWeight = blockWeight;
-    decomposer.m_range       = ⦥
+    decomposer.m_range = ⦥
 
     decomposer.DecomposeRangeHelper();
 }
@@ -626,7 +621,7 @@ GenTree* DecomposeLongs::DecomposeCast(LIR::Use& use)
             else
             {
                 LIR::Use src(Range(), &(cast->AsOp()->gtOp1), cast);
-                unsigned lclNum = src.ReplaceWithLclVar(m_compiler, m_blockWeight);
+                unsigned lclNum = src.ReplaceWithLclVar(m_compiler);
 
                 loResult = src.Def();
 
@@ -768,22 +763,22 @@ GenTree* DecomposeLongs::DecomposeStoreInd(LIR::Use& use)
 
     // Save address to a temp. It is used in storeIndLow and storeIndHigh trees.
     LIR::Use address(Range(), &tree->AsOp()->gtOp1, tree);
-    address.ReplaceWithLclVar(m_compiler, m_blockWeight);
+    address.ReplaceWithLclVar(m_compiler);
     JITDUMP("[DecomposeStoreInd]: Saving address tree to a temp var:\n");
     DISPTREERANGE(Range(), address.Def());
 
     if (!gtLong->AsOp()->gtOp1->OperIsLeaf())
     {
         LIR::Use op1(Range(), &gtLong->AsOp()->gtOp1, gtLong);
-        op1.ReplaceWithLclVar(m_compiler, m_blockWeight);
+        op1.ReplaceWithLclVar(m_compiler);
         JITDUMP("[DecomposeStoreInd]: Saving low data tree to a temp var:\n");
         DISPTREERANGE(Range(), op1.Def());
     }
 
     if (!gtLong->AsOp()->gtOp2->OperIsLeaf())
     {
         LIR::Use op2(Range(), &gtLong->AsOp()->gtOp2, gtLong);
-        op2.ReplaceWithLclVar(m_compiler, m_blockWeight);
+        op2.ReplaceWithLclVar(m_compiler);
         JITDUMP("[DecomposeStoreInd]: Saving high data tree to a temp var:\n");
         DISPTREERANGE(Range(), op2.Def());
     }
@@ -841,7 +836,7 @@ GenTree* DecomposeLongs::DecomposeInd(LIR::Use& use)
     GenTree* indLow = use.Def();
 
     LIR::Use address(Range(), &indLow->AsOp()->gtOp1, indLow);
-    address.ReplaceWithLclVar(m_compiler, m_blockWeight);
+    address.ReplaceWithLclVar(m_compiler);
     JITDUMP("[DecomposeInd]: Saving addr tree to a temp var:\n");
     DISPTREERANGE(Range(), address.Def());
 
@@ -1151,7 +1146,7 @@ GenTree* DecomposeLongs::DecomposeShift(LIR::Use& use)
                         // x = x << 32
 
                         LIR::Use loOp1Use(Range(), &gtLong->AsOp()->gtOp1, gtLong);
-                        loOp1Use.ReplaceWithLclVar(m_compiler, m_blockWeight);
+                        loOp1Use.ReplaceWithLclVar(m_compiler);
 
                         hiResult = loOp1Use.Def();
                         Range().Remove(gtLong);
@@ -1434,10 +1429,10 @@ GenTree* DecomposeLongs::DecomposeRotate(LIR::Use& use)
     {
         // If the rotate amount is 32, then swap hi and lo
         LIR::Use loOp1Use(Range(), &gtLong->AsOp()->gtOp1, gtLong);
-        loOp1Use.ReplaceWithLclVar(m_compiler, m_blockWeight);
+        loOp1Use.ReplaceWithLclVar(m_compiler);
 
         LIR::Use hiOp1Use(Range(), &gtLong->AsOp()->gtOp2, gtLong);
-        hiOp1Use.ReplaceWithLclVar(m_compiler, m_blockWeight);
+        hiOp1Use.ReplaceWithLclVar(m_compiler);
 
         hiResult              = loOp1Use.Def();
         loResult              = hiOp1Use.Def();
@@ -1821,7 +1816,7 @@ GenTree* DecomposeLongs::StoreNodeToVar(LIR::Use& use)
     }
 
     // Otherwise, we need to force var = call()
-    unsigned varNum                              = use.ReplaceWithLclVar(m_compiler, m_blockWeight);
+    unsigned varNum                              = use.ReplaceWithLclVar(m_compiler);
     m_compiler->lvaTable[varNum].lvIsMultiRegRet = true;
 
     // Decompose the new LclVar use
@@ -1848,7 +1843,7 @@ GenTree* DecomposeLongs::RepresentOpAsLocalVar(GenTree* op, GenTree* user, GenTr
     else
     {
         LIR::Use opUse(Range(), edge, user);
-        opUse.ReplaceWithLclVar(m_compiler, m_blockWeight);
+        opUse.ReplaceWithLclVar(m_compiler);
         return *edge;
     }
 }

src/coreclr/src/jit/decomposelongs.h

@@ -25,7 +25,7 @@ class DecomposeLongs
     void PrepareForDecomposition();
     void DecomposeBlock(BasicBlock* block);
 
-    static void DecomposeRange(Compiler* compiler, unsigned blockWeight, LIR::Range& range);
+    static void DecomposeRange(Compiler* compiler, LIR::Range& range);
 
 private:
     inline LIR::Range& Range() const
@@ -69,7 +69,6 @@ class DecomposeLongs
 
     // Data
     Compiler*   m_compiler;
-    unsigned    m_blockWeight;
     LIR::Range* m_range;
 };