Skip to content

JIT: Always compute loop iteration estimate in loop inversion if we have PGO data#116104

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
amanasifkhalid merged 11 commits into from
Aug 5, 2025
Merged

JIT: Always compute loop iteration estimate in loop inversion if we have PGO data #116104

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
11 commits
Select commit Hold shift + click to select a range
672b2c0
More precise loop iteration computation
amanasifkhalid May 29, 2025
d8e96d6
Skip loops with low iteration counts
amanasifkhalid May 29, 2025
464d8e4
Comments
amanasifkhalid May 29, 2025
21503d1
Merge branch 'main' into loop-inversion-iteration-count
amanasifkhalid May 29, 2025
482aec8
Remove heuristic
amanasifkhalid May 30, 2025
9aee3aa
Merge branch 'loop-inversion-iteration-count' of https://github.com/a…
amanasifkhalid May 30, 2025
c08588c
Merge branch 'main' into loop-inversion-iteration-count
amanasifkhalid Jun 2, 2025
0e0ba90
Use loop entry-relative iteration computation
amanasifkhalid Jun 2, 2025
414295f
Merge from main
amanasifkhalid Aug 4, 2025
c7083b6
Cleanup
amanasifkhalid Aug 4, 2025
80cb61f
Remove dead code
amanasifkhalid Aug 4, 2025
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
2 changes: 0 additions & 2 deletions src/coreclr/jit/compiler.h
View file
Open in desktop
Original file line numberDiff line numberDiff line change
Expand Up@@ -6195,8 +6195,6 @@ class Compiler

bool fgDedupReturnComparison(BasicBlock* block);

bool fgIsForwardBranch(BasicBlock* bJump, BasicBlock* bDest, BasicBlock* bSrc = nullptr);

bool fgUpdateFlowGraph(bool doTailDup = false, bool isPhase = false);
PhaseStatus fgUpdateFlowGraphPhase();

Expand Down
33 changes: 0 additions & 33 deletions src/coreclr/jit/fgbasic.cpp
View file
Open in desktop
Original file line numberDiff line numberDiff line change
Expand Up@@ -5218,39 +5218,6 @@ void Compiler::fgPrepareCallFinallyRetForRemoval(BasicBlock* block)
block->SetKind(BBJ_ALWAYS);
}

/*****************************************************************************
*
* Is the BasicBlock bJump a forward branch?
* Optionally bSrc can be supplied to indicate that
* bJump must be forward with respect to bSrc
*/
bool Compiler::fgIsForwardBranch(BasicBlock* bJump, BasicBlock* bDest, BasicBlock* bSrc /* = NULL */)
{
assert((bJump->KindIs(BBJ_ALWAYS, BBJ_CALLFINALLYRET) && bJump->TargetIs(bDest)) ||
(bJump->KindIs(BBJ_COND) && bJump->TrueTargetIs(bDest)));

bool result = false;
BasicBlock* bTemp = (bSrc == nullptr) ? bJump : bSrc;

while (true)
{
bTemp = bTemp->Next();

if (bTemp == nullptr)
{
break;
}

if (bTemp == bDest)
{
result = true;
break;
}
}

return result;
}

/*****************************************************************************
*
* Function called to move the range of blocks [bStart .. bEnd].
Expand Down
98 changes: 36 additions & 62 deletions src/coreclr/jit/optimizer.cpp
View file
Open in desktop
Original file line numberDiff line numberDiff line change
Expand Up@@ -1901,6 +1901,42 @@ bool Compiler::optTryInvertWhileLoop(FlowGraphNaturalLoop* loop)
JITDUMP("Condition in block " FMT_BB " of loop " FMT_LP " is a candidate for duplication to invert the loop\n",
condBlock->bbNum, loop->GetIndex());

weight_t loopIterations = BB_LOOP_WEIGHT_SCALE;
const bool haveProfileWeights = fgIsUsingProfileWeights();
const weight_t weightPreheader = preheader->bbWeight;
const weight_t weightCond = condBlock->bbWeight;
const weight_t weightStayInLoopSucc = stayInLoopSucc->bbWeight;

// If we have profile data then we calculate the number of times
// the loop will iterate into loopIterations
if (haveProfileWeights)
{
assert(preheader->hasProfileWeight());
assert(condBlock->hasProfileWeight());
assert(stayInLoopSucc->hasProfileWeight());

// If this while loop never iterates then don't bother transforming
//
if (weightStayInLoopSucc == BB_ZERO_WEIGHT)
{
JITDUMP("No loop-inversion for " FMT_LP " since the in-loop successor " FMT_BB " has 0 weight\n",
loop->GetIndex(), preheader->bbNum);
return false;
}

// Determine average iteration count
//
// weightTop is the number of time this loop executes
// weightTest is the number of times that we consider entering or remaining in the loop
// loopIterations is the average number of times that this loop iterates
//
// If profile is inaccurate, use other data to provide a credible estimate.
// The value should at least be >= weightPreheader.
//
const weight_t loopEntries = max(weightPreheader, weightCond - weightStayInLoopSucc);
loopIterations = weightStayInLoopSucc / loopEntries;
}

// Check if loop is small enough to consider for inversion.
// Large loops are less likely to benefit from inversion.
const int invertSizeLimit = JitConfig.JitLoopInversionSizeLimit();
Expand DownExpand Up@@ -1957,68 +1993,6 @@ bool Compiler::optTryInvertWhileLoop(FlowGraphNaturalLoop* loop)
}
}

weight_t loopIterations = BB_LOOP_WEIGHT_SCALE;
bool haveProfileWeights = false;
weight_t const weightPreheader = preheader->bbWeight;
weight_t const weightCond = condBlock->bbWeight;
weight_t const weightStayInLoopSucc = stayInLoopSucc->bbWeight;

// If we have profile data then we calculate the number of times
// the loop will iterate into loopIterations
if (fgIsUsingProfileWeights())
{
// Only rely upon the profile weight when all three of these blocks
// have good profile weights
if (preheader->hasProfileWeight() && condBlock->hasProfileWeight() && stayInLoopSucc->hasProfileWeight())
{
// If this while loop never iterates then don't bother transforming
//
if (weightStayInLoopSucc == BB_ZERO_WEIGHT)
{
JITDUMP("No loop-inversion for " FMT_LP " since the in-loop successor " FMT_BB " has 0 weight\n",
loop->GetIndex(), preheader->bbNum);
return false;
}

haveProfileWeights = true;

// We generally expect weightCond > weightStayInLoopSucc
//
// Tolerate small inconsistencies...
//
if (!fgProfileWeightsConsistent(weightPreheader + weightStayInLoopSucc, weightCond))
{
JITDUMP("Profile weights locally inconsistent: preheader " FMT_WT ", stayInLoopSucc " FMT_WT
", cond " FMT_WT "\n",
weightPreheader, weightStayInLoopSucc, weightCond);
}
else
{
// Determine average iteration count
//
// weightTop is the number of time this loop executes
// weightTest is the number of times that we consider entering or remaining in the loop
// loopIterations is the average number of times that this loop iterates
//
weight_t loopEntries = weightCond - weightStayInLoopSucc;

// If profile is inaccurate, try and use other data to provide a credible estimate.
// The value should at least be >= weightBlock.
//
if (loopEntries < weightPreheader)
{
loopEntries = weightPreheader;
}

loopIterations = weightStayInLoopSucc / loopEntries;
}
}
else
{
JITDUMP("Missing profile data for loop!\n");
}
}

unsigned maxDupCostSz = 34;

if ((compCodeOpt() == FAST_CODE) || compStressCompile(STRESS_DO_WHILE_LOOPS, 30))
Expand Down
Loading
, 'i'); if (__m === '*' || __re.test(location.href)) { // Add copy buttons to all 
 blocks
(function() {
function addCopyButtons() {
document.querySelectorAll('pre code').forEach(function(codeBlock) {
if (codeBlock.parentElement.hasAttribute('data-copy-added')) return;
codeBlock.parentElement.setAttribute('data-copy-added', 'true');
var btn = document.createElement('button');
btn.textContent = 'Copy';
btn.style.cssText = 'position:absolute;top:4px;right:4px;padding:2px 8px;font-size:11px;background:#4ecdc4;border:none;border-radius:4px;color:#1a1a2e;cursor:pointer;opacity:0.7;transition:opacity 0.2s;';
btn.onmouseover = function() { this.style.opacity = '1'; };
btn.onmouseout = function() { this.style.opacity = '0.7'; };
btn.onclick = function() {
navigator.clipboard.writeText(codeBlock.textContent).then(function() {
btn.textContent = 'Copied!';
setTimeout(function() { btn.textContent = 'Copy'; }, 1500);
});
};
codeBlock.parentElement.style.position = 'relative';
codeBlock.parentElement.appendChild(btn);
});
}
addCopyButtons();
// Re-run on dynamic content
var observer = new MutationObserver(addCopyButtons);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Add Copy Buttons to Code Blocks]', __e); }
})();
(function(){
try {
var __m = "github.com";
var __re = new RegExp('^' + "github\\.com" + '
JIT: Always compute loop iteration estimate in loop inversion if we have PGO data by amanasifkhalid · Pull Request #116104 · dotnet/runtime · GitHub
Skip to content
JIT: Always compute loop iteration estimate in loop inversion if we have PGO data#116104

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

 Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and
privacy statement. We’ll occasionally send you account related emails.

Already on GitHub?
Sign in
to your account

 Merged

amanasifkhalid
merged 11 commits into

from

Aug 5, 2025
 Merged


JIT: Always compute loop iteration estimate in loop inversion if we have PGO data
#116104
Show file tree
Hide file tree
 Changes from all commits
Commits

Show all changes


11 commits


Select commit
Hold shift + click to select a range
672b2c0

More precise loop iteration computation


amanasifkhalid May 29, 2025
d8e96d6

Skip loops with low iteration counts


amanasifkhalid May 29, 2025
464d8e4

Comments


amanasifkhalid May 29, 2025
21503d1

Merge branch 'main' into loop-inversion-iteration-count


amanasifkhalid May 29, 2025
482aec8

Remove heuristic


amanasifkhalid May 30, 2025
9aee3aa

Merge branch 'loop-inversion-iteration-count' of https://github.com/a…


amanasifkhalid May 30, 2025
c08588c

Merge branch 'main' into loop-inversion-iteration-count


amanasifkhalid Jun 2, 2025
0e0ba90

Use loop entry-relative iteration computation


amanasifkhalid Jun 2, 2025
414295f

Merge from main


amanasifkhalid Aug 4, 2025
c7083b6

Cleanup


amanasifkhalid Aug 4, 2025
80cb61f

Remove dead code


amanasifkhalid Aug 4, 2025

File filter

Filter by extension
Filter by extension
Conversations

Failed to load comments. 
Loading
Jump to

Jump to file


Failed to load files. 
Loading
 Diff view

 Diff view


2 changes: 0 additions & 2 deletions
src/coreclr/jit/compiler.h

View file


Open in desktop

Original file line numberDiff line numberDiff line change
Expand Up@@ -6195,8 +6195,6 @@ class Compiler

 bool fgDedupReturnComparison(BasicBlock* block);

 bool fgIsForwardBranch(BasicBlock* bJump, BasicBlock* bDest, BasicBlock* bSrc = nullptr);

 bool fgUpdateFlowGraph(bool doTailDup = false, bool isPhase = false);
 PhaseStatus fgUpdateFlowGraphPhase();

Expand Down

33 changes: 0 additions & 33 deletions
src/coreclr/jit/fgbasic.cpp

View file


Open in desktop

Original file line numberDiff line numberDiff line change
Expand Up@@ -5218,39 +5218,6 @@ void Compiler::fgPrepareCallFinallyRetForRemoval(BasicBlock* block)
 block->SetKind(BBJ_ALWAYS);
}

/*****************************************************************************
 *
 * Is the BasicBlock bJump a forward branch?
 * Optionally bSrc can be supplied to indicate that
 * bJump must be forward with respect to bSrc
 */
bool Compiler::fgIsForwardBranch(BasicBlock* bJump, BasicBlock* bDest, BasicBlock* bSrc /* = NULL */)
{
 assert((bJump->KindIs(BBJ_ALWAYS, BBJ_CALLFINALLYRET) && bJump->TargetIs(bDest)) ||
 (bJump->KindIs(BBJ_COND) && bJump->TrueTargetIs(bDest)));

 bool result = false;
 BasicBlock* bTemp = (bSrc == nullptr) ? bJump : bSrc;

 while (true)
 {
 bTemp = bTemp->Next();

 if (bTemp == nullptr)
 {
 break;
 }

 if (bTemp == bDest)
 {
 result = true;
 break;
 }
 }

 return result;
}

/*****************************************************************************
 *
 * Function called to move the range of blocks [bStart .. bEnd].
Expand Down

98 changes: 36 additions & 62 deletions
src/coreclr/jit/optimizer.cpp

View file


Open in desktop

Original file line numberDiff line numberDiff line change
Expand Up@@ -1901,6 +1901,42 @@ bool Compiler::optTryInvertWhileLoop(FlowGraphNaturalLoop* loop)
 JITDUMP("Condition in block " FMT_BB " of loop " FMT_LP " is a candidate for duplication to invert the loop\n",
 condBlock->bbNum, loop->GetIndex());

 weight_t loopIterations = BB_LOOP_WEIGHT_SCALE;
 const bool haveProfileWeights = fgIsUsingProfileWeights();
 const weight_t weightPreheader = preheader->bbWeight;
 const weight_t weightCond = condBlock->bbWeight;
 const weight_t weightStayInLoopSucc = stayInLoopSucc->bbWeight;

 // If we have profile data then we calculate the number of times
 // the loop will iterate into loopIterations
 if (haveProfileWeights)
 {
 assert(preheader->hasProfileWeight());
 assert(condBlock->hasProfileWeight());
 assert(stayInLoopSucc->hasProfileWeight());

 // If this while loop never iterates then don't bother transforming
 //
 if (weightStayInLoopSucc == BB_ZERO_WEIGHT)
 {
 JITDUMP("No loop-inversion for " FMT_LP " since the in-loop successor " FMT_BB " has 0 weight\n",
 loop->GetIndex(), preheader->bbNum);
 return false;
 }

 // Determine average iteration count
 //
 // weightTop is the number of time this loop executes
 // weightTest is the number of times that we consider entering or remaining in the loop
 // loopIterations is the average number of times that this loop iterates
 //
 // If profile is inaccurate, use other data to provide a credible estimate.
 // The value should at least be >= weightPreheader.
 //
 const weight_t loopEntries = max(weightPreheader, weightCond - weightStayInLoopSucc);
 loopIterations = weightStayInLoopSucc / loopEntries;
 }

 // Check if loop is small enough to consider for inversion.
 // Large loops are less likely to benefit from inversion.
 const int invertSizeLimit = JitConfig.JitLoopInversionSizeLimit();
Expand DownExpand Up@@ -1957,68 +1993,6 @@ bool Compiler::optTryInvertWhileLoop(FlowGraphNaturalLoop* loop)
 }
 }

 weight_t loopIterations = BB_LOOP_WEIGHT_SCALE;
 bool haveProfileWeights = false;
 weight_t const weightPreheader = preheader->bbWeight;
 weight_t const weightCond = condBlock->bbWeight;
 weight_t const weightStayInLoopSucc = stayInLoopSucc->bbWeight;

 // If we have profile data then we calculate the number of times
 // the loop will iterate into loopIterations
 if (fgIsUsingProfileWeights())
 {
 // Only rely upon the profile weight when all three of these blocks
 // have good profile weights
 if (preheader->hasProfileWeight() && condBlock->hasProfileWeight() && stayInLoopSucc->hasProfileWeight())
 {
 // If this while loop never iterates then don't bother transforming
 //
 if (weightStayInLoopSucc == BB_ZERO_WEIGHT)
 {
 JITDUMP("No loop-inversion for " FMT_LP " since the in-loop successor " FMT_BB " has 0 weight\n",
 loop->GetIndex(), preheader->bbNum);
 return false;
 }

 haveProfileWeights = true;

 // We generally expect weightCond > weightStayInLoopSucc
 //
 // Tolerate small inconsistencies...
 //
 if (!fgProfileWeightsConsistent(weightPreheader + weightStayInLoopSucc, weightCond))
 {
 JITDUMP("Profile weights locally inconsistent: preheader " FMT_WT ", stayInLoopSucc " FMT_WT
 ", cond " FMT_WT "\n",
 weightPreheader, weightStayInLoopSucc, weightCond);
 }
 else
 {
 // Determine average iteration count
 //
 // weightTop is the number of time this loop executes
 // weightTest is the number of times that we consider entering or remaining in the loop
 // loopIterations is the average number of times that this loop iterates
 //
 weight_t loopEntries = weightCond - weightStayInLoopSucc;

 // If profile is inaccurate, try and use other data to provide a credible estimate.
 // The value should at least be >= weightBlock.
 //
 if (loopEntries < weightPreheader)
 {
 loopEntries = weightPreheader;
 }

 loopIterations = weightStayInLoopSucc / loopEntries;
 }
 }
 else
 {
 JITDUMP("Missing profile data for loop!\n");
 }
 }

 unsigned maxDupCostSz = 34;

 if ((compCodeOpt() == FAST_CODE) || compStressCompile(STRESS_DO_WHILE_LOOPS, 30))
Expand Down
Loading

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Force GitHub README to respect dark mode
(function() {
var style = document.createElement('style');
style.textContent = '
.markdown-body {
color-scheme: dark light;
}
.markdown-body pre { background: #161b22 !important; }
.markdown-body code { background: rgba(110, 118, 129, 0.4) !important; }
.markdown-body table th, .markdown-body table td { border-color: #30363d !important; }
.markdown-body img { background: #0d1117; }
.markdown-body blockquote { border-left-color: #8b949e; }
.markdown-body hr { border-color: #30363d; }
';
document.head.appendChild(style);
})();
}
} catch(__e) { console.warn('[Userscript:GitHub Dark Mode README Fix]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
JIT: Always compute loop iteration estimate in loop inversion if we have PGO data by amanasifkhalid · Pull Request #116104 · dotnet/runtime · GitHub
Skip to content
JIT: Always compute loop iteration estimate in loop inversion if we have PGO data#116104

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

 Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and
privacy statement. We’ll occasionally send you account related emails.

Already on GitHub?
Sign in
to your account

 Merged

amanasifkhalid
merged 11 commits into

from

Aug 5, 2025
 Merged


JIT: Always compute loop iteration estimate in loop inversion if we have PGO data
#116104
Show file tree
Hide file tree
 Changes from all commits
Commits

Show all changes


11 commits


Select commit
Hold shift + click to select a range
672b2c0

More precise loop iteration computation


amanasifkhalid May 29, 2025
d8e96d6

Skip loops with low iteration counts


amanasifkhalid May 29, 2025
464d8e4

Comments


amanasifkhalid May 29, 2025
21503d1

Merge branch 'main' into loop-inversion-iteration-count


amanasifkhalid May 29, 2025
482aec8

Remove heuristic


amanasifkhalid May 30, 2025
9aee3aa

Merge branch 'loop-inversion-iteration-count' of https://github.com/a…


amanasifkhalid May 30, 2025
c08588c

Merge branch 'main' into loop-inversion-iteration-count


amanasifkhalid Jun 2, 2025
0e0ba90

Use loop entry-relative iteration computation


amanasifkhalid Jun 2, 2025
414295f

Merge from main


amanasifkhalid Aug 4, 2025
c7083b6

Cleanup


amanasifkhalid Aug 4, 2025
80cb61f

Remove dead code


amanasifkhalid Aug 4, 2025

File filter

Filter by extension
Filter by extension
Conversations

Failed to load comments. 
Loading
Jump to

Jump to file


Failed to load files. 
Loading
 Diff view

 Diff view


2 changes: 0 additions & 2 deletions
src/coreclr/jit/compiler.h

View file


Open in desktop

Original file line numberDiff line numberDiff line change
Expand Up@@ -6195,8 +6195,6 @@ class Compiler

 bool fgDedupReturnComparison(BasicBlock* block);

 bool fgIsForwardBranch(BasicBlock* bJump, BasicBlock* bDest, BasicBlock* bSrc = nullptr);

 bool fgUpdateFlowGraph(bool doTailDup = false, bool isPhase = false);
 PhaseStatus fgUpdateFlowGraphPhase();

Expand Down

33 changes: 0 additions & 33 deletions
src/coreclr/jit/fgbasic.cpp

View file


Open in desktop

Original file line numberDiff line numberDiff line change
Expand Up@@ -5218,39 +5218,6 @@ void Compiler::fgPrepareCallFinallyRetForRemoval(BasicBlock* block)
 block->SetKind(BBJ_ALWAYS);
}

/*****************************************************************************
 *
 * Is the BasicBlock bJump a forward branch?
 * Optionally bSrc can be supplied to indicate that
 * bJump must be forward with respect to bSrc
 */
bool Compiler::fgIsForwardBranch(BasicBlock* bJump, BasicBlock* bDest, BasicBlock* bSrc /* = NULL */)
{
 assert((bJump->KindIs(BBJ_ALWAYS, BBJ_CALLFINALLYRET) && bJump->TargetIs(bDest)) ||
 (bJump->KindIs(BBJ_COND) && bJump->TrueTargetIs(bDest)));

 bool result = false;
 BasicBlock* bTemp = (bSrc == nullptr) ? bJump : bSrc;

 while (true)
 {
 bTemp = bTemp->Next();

 if (bTemp == nullptr)
 {
 break;
 }

 if (bTemp == bDest)
 {
 result = true;
 break;
 }
 }

 return result;
}

/*****************************************************************************
 *
 * Function called to move the range of blocks [bStart .. bEnd].
Expand Down

98 changes: 36 additions & 62 deletions
src/coreclr/jit/optimizer.cpp

View file


Open in desktop

Original file line numberDiff line numberDiff line change
Expand Up@@ -1901,6 +1901,42 @@ bool Compiler::optTryInvertWhileLoop(FlowGraphNaturalLoop* loop)
 JITDUMP("Condition in block " FMT_BB " of loop " FMT_LP " is a candidate for duplication to invert the loop\n",
 condBlock->bbNum, loop->GetIndex());

 weight_t loopIterations = BB_LOOP_WEIGHT_SCALE;
 const bool haveProfileWeights = fgIsUsingProfileWeights();
 const weight_t weightPreheader = preheader->bbWeight;
 const weight_t weightCond = condBlock->bbWeight;
 const weight_t weightStayInLoopSucc = stayInLoopSucc->bbWeight;

 // If we have profile data then we calculate the number of times
 // the loop will iterate into loopIterations
 if (haveProfileWeights)
 {
 assert(preheader->hasProfileWeight());
 assert(condBlock->hasProfileWeight());
 assert(stayInLoopSucc->hasProfileWeight());

 // If this while loop never iterates then don't bother transforming
 //
 if (weightStayInLoopSucc == BB_ZERO_WEIGHT)
 {
 JITDUMP("No loop-inversion for " FMT_LP " since the in-loop successor " FMT_BB " has 0 weight\n",
 loop->GetIndex(), preheader->bbNum);
 return false;
 }

 // Determine average iteration count
 //
 // weightTop is the number of time this loop executes
 // weightTest is the number of times that we consider entering or remaining in the loop
 // loopIterations is the average number of times that this loop iterates
 //
 // If profile is inaccurate, use other data to provide a credible estimate.
 // The value should at least be >= weightPreheader.
 //
 const weight_t loopEntries = max(weightPreheader, weightCond - weightStayInLoopSucc);
 loopIterations = weightStayInLoopSucc / loopEntries;
 }

 // Check if loop is small enough to consider for inversion.
 // Large loops are less likely to benefit from inversion.
 const int invertSizeLimit = JitConfig.JitLoopInversionSizeLimit();
Expand DownExpand Up@@ -1957,68 +1993,6 @@ bool Compiler::optTryInvertWhileLoop(FlowGraphNaturalLoop* loop)
 }
 }

 weight_t loopIterations = BB_LOOP_WEIGHT_SCALE;
 bool haveProfileWeights = false;
 weight_t const weightPreheader = preheader->bbWeight;
 weight_t const weightCond = condBlock->bbWeight;
 weight_t const weightStayInLoopSucc = stayInLoopSucc->bbWeight;

 // If we have profile data then we calculate the number of times
 // the loop will iterate into loopIterations
 if (fgIsUsingProfileWeights())
 {
 // Only rely upon the profile weight when all three of these blocks
 // have good profile weights
 if (preheader->hasProfileWeight() && condBlock->hasProfileWeight() && stayInLoopSucc->hasProfileWeight())
 {
 // If this while loop never iterates then don't bother transforming
 //
 if (weightStayInLoopSucc == BB_ZERO_WEIGHT)
 {
 JITDUMP("No loop-inversion for " FMT_LP " since the in-loop successor " FMT_BB " has 0 weight\n",
 loop->GetIndex(), preheader->bbNum);
 return false;
 }

 haveProfileWeights = true;

 // We generally expect weightCond > weightStayInLoopSucc
 //
 // Tolerate small inconsistencies...
 //
 if (!fgProfileWeightsConsistent(weightPreheader + weightStayInLoopSucc, weightCond))
 {
 JITDUMP("Profile weights locally inconsistent: preheader " FMT_WT ", stayInLoopSucc " FMT_WT
 ", cond " FMT_WT "\n",
 weightPreheader, weightStayInLoopSucc, weightCond);
 }
 else
 {
 // Determine average iteration count
 //
 // weightTop is the number of time this loop executes
 // weightTest is the number of times that we consider entering or remaining in the loop
 // loopIterations is the average number of times that this loop iterates
 //
 weight_t loopEntries = weightCond - weightStayInLoopSucc;

 // If profile is inaccurate, try and use other data to provide a credible estimate.
 // The value should at least be >= weightBlock.
 //
 if (loopEntries < weightPreheader)
 {
 loopEntries = weightPreheader;
 }

 loopIterations = weightStayInLoopSucc / loopEntries;
 }
 }
 else
 {
 JITDUMP("Missing profile data for loop!\n");
 }
 }

 unsigned maxDupCostSz = 34;

 if ((compCodeOpt() == FAST_CODE) || compStressCompile(STRESS_DO_WHILE_LOOPS, 30))
Expand Down
Loading

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Highlight search terms from Google/DuckDuckGo/Bing referrer
(function() {
var ref = document.referrer;
var terms = [];
if (ref.includes('google.com') || ref.includes('duckduckgo.com') || ref.includes('bing.com')) {
var url = new URL(ref);
var q = url.searchParams.get('q') || url.searchParams.get('p');
if (q) {
terms = q.split(/\s+/).filter(function(t) { return t.length > 2; });
}
}
if (terms.length === 0) return;
var style = document.createElement('style');
style.textContent = '.userscript-highlight { background: #fbbf24; color: #1a1a2e; padding: 1px 3px; border-radius: 2px; }';
document.head.appendChild(style);
function highlight(node) {
if (node.nodeType === 3) { // text node
var text = node.textContent;
var found = false;
terms.forEach(function(term) {
var regex = new RegExp('(' + term.replace(/[.*+?^${}()|[\]\\]/g, '\\') + ')', 'gi');
if (regex.test(text)) {
found = true;
var frag = document.createDocumentFragment();
var parts = text.split(regex);
parts.forEach(function(part, i) {
if (i % 2 === 0) {
frag.appendChild(document.createTextNode(part));
} else {
var span = document.createElement('span');
span.className = 'userscript-highlight';
span.textContent = part;
frag.appendChild(span);
}
});
node.parentNode.replaceChild(frag, node);
}
});
} else if (node.nodeType === 1 && node.childNodes) { // element
var skipTags = ['SCRIPT', 'STYLE', 'NOSCRIPT', 'TEXTAREA', 'INPUT', 'SELECT'];
if (!skipTags.includes(node.tagName)) {
Array.from(node.childNodes).forEach(highlight);
}
}
}
highlight(document.body);
// Re-highlight on dynamic content
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1 || node.nodeType === 3) highlight(node);
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Highlight Search Terms]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
JIT: Always compute loop iteration estimate in loop inversion if we have PGO data by amanasifkhalid · Pull Request #116104 · dotnet/runtime · GitHub
Skip to content
JIT: Always compute loop iteration estimate in loop inversion if we have PGO data#116104

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

 Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and
privacy statement. We’ll occasionally send you account related emails.

Already on GitHub?
Sign in
to your account

 Merged

amanasifkhalid
merged 11 commits into

from

Aug 5, 2025
 Merged


JIT: Always compute loop iteration estimate in loop inversion if we have PGO data
#116104
Show file tree
Hide file tree
 Changes from all commits
Commits

Show all changes


11 commits


Select commit
Hold shift + click to select a range
672b2c0

More precise loop iteration computation


amanasifkhalid May 29, 2025
d8e96d6

Skip loops with low iteration counts


amanasifkhalid May 29, 2025
464d8e4

Comments


amanasifkhalid May 29, 2025
21503d1

Merge branch 'main' into loop-inversion-iteration-count


amanasifkhalid May 29, 2025
482aec8

Remove heuristic


amanasifkhalid May 30, 2025
9aee3aa

Merge branch 'loop-inversion-iteration-count' of https://github.com/a…


amanasifkhalid May 30, 2025
c08588c

Merge branch 'main' into loop-inversion-iteration-count


amanasifkhalid Jun 2, 2025
0e0ba90

Use loop entry-relative iteration computation


amanasifkhalid Jun 2, 2025
414295f

Merge from main


amanasifkhalid Aug 4, 2025
c7083b6

Cleanup


amanasifkhalid Aug 4, 2025
80cb61f

Remove dead code


amanasifkhalid Aug 4, 2025

File filter

Filter by extension
Filter by extension
Conversations

Failed to load comments. 
Loading
Jump to

Jump to file


Failed to load files. 
Loading
 Diff view

 Diff view


2 changes: 0 additions & 2 deletions
src/coreclr/jit/compiler.h

View file


Open in desktop

Original file line numberDiff line numberDiff line change
Expand Up@@ -6195,8 +6195,6 @@ class Compiler

 bool fgDedupReturnComparison(BasicBlock* block);

 bool fgIsForwardBranch(BasicBlock* bJump, BasicBlock* bDest, BasicBlock* bSrc = nullptr);

 bool fgUpdateFlowGraph(bool doTailDup = false, bool isPhase = false);
 PhaseStatus fgUpdateFlowGraphPhase();

Expand Down

33 changes: 0 additions & 33 deletions
src/coreclr/jit/fgbasic.cpp

View file


Open in desktop

Original file line numberDiff line numberDiff line change
Expand Up@@ -5218,39 +5218,6 @@ void Compiler::fgPrepareCallFinallyRetForRemoval(BasicBlock* block)
 block->SetKind(BBJ_ALWAYS);
}

/*****************************************************************************
 *
 * Is the BasicBlock bJump a forward branch?
 * Optionally bSrc can be supplied to indicate that
 * bJump must be forward with respect to bSrc
 */
bool Compiler::fgIsForwardBranch(BasicBlock* bJump, BasicBlock* bDest, BasicBlock* bSrc /* = NULL */)
{
 assert((bJump->KindIs(BBJ_ALWAYS, BBJ_CALLFINALLYRET) && bJump->TargetIs(bDest)) ||
 (bJump->KindIs(BBJ_COND) && bJump->TrueTargetIs(bDest)));

 bool result = false;
 BasicBlock* bTemp = (bSrc == nullptr) ? bJump : bSrc;

 while (true)
 {
 bTemp = bTemp->Next();

 if (bTemp == nullptr)
 {
 break;
 }

 if (bTemp == bDest)
 {
 result = true;
 break;
 }
 }

 return result;
}

/*****************************************************************************
 *
 * Function called to move the range of blocks [bStart .. bEnd].
Expand Down

98 changes: 36 additions & 62 deletions
src/coreclr/jit/optimizer.cpp

View file


Open in desktop

Original file line numberDiff line numberDiff line change
Expand Up@@ -1901,6 +1901,42 @@ bool Compiler::optTryInvertWhileLoop(FlowGraphNaturalLoop* loop)
 JITDUMP("Condition in block " FMT_BB " of loop " FMT_LP " is a candidate for duplication to invert the loop\n",
 condBlock->bbNum, loop->GetIndex());

 weight_t loopIterations = BB_LOOP_WEIGHT_SCALE;
 const bool haveProfileWeights = fgIsUsingProfileWeights();
 const weight_t weightPreheader = preheader->bbWeight;
 const weight_t weightCond = condBlock->bbWeight;
 const weight_t weightStayInLoopSucc = stayInLoopSucc->bbWeight;

 // If we have profile data then we calculate the number of times
 // the loop will iterate into loopIterations
 if (haveProfileWeights)
 {
 assert(preheader->hasProfileWeight());
 assert(condBlock->hasProfileWeight());
 assert(stayInLoopSucc->hasProfileWeight());

 // If this while loop never iterates then don't bother transforming
 //
 if (weightStayInLoopSucc == BB_ZERO_WEIGHT)
 {
 JITDUMP("No loop-inversion for " FMT_LP " since the in-loop successor " FMT_BB " has 0 weight\n",
 loop->GetIndex(), preheader->bbNum);
 return false;
 }

 // Determine average iteration count
 //
 // weightTop is the number of time this loop executes
 // weightTest is the number of times that we consider entering or remaining in the loop
 // loopIterations is the average number of times that this loop iterates
 //
 // If profile is inaccurate, use other data to provide a credible estimate.
 // The value should at least be >= weightPreheader.
 //
 const weight_t loopEntries = max(weightPreheader, weightCond - weightStayInLoopSucc);
 loopIterations = weightStayInLoopSucc / loopEntries;
 }

 // Check if loop is small enough to consider for inversion.
 // Large loops are less likely to benefit from inversion.
 const int invertSizeLimit = JitConfig.JitLoopInversionSizeLimit();
Expand DownExpand Up@@ -1957,68 +1993,6 @@ bool Compiler::optTryInvertWhileLoop(FlowGraphNaturalLoop* loop)
 }
 }

 weight_t loopIterations = BB_LOOP_WEIGHT_SCALE;
 bool haveProfileWeights = false;
 weight_t const weightPreheader = preheader->bbWeight;
 weight_t const weightCond = condBlock->bbWeight;
 weight_t const weightStayInLoopSucc = stayInLoopSucc->bbWeight;

 // If we have profile data then we calculate the number of times
 // the loop will iterate into loopIterations
 if (fgIsUsingProfileWeights())
 {
 // Only rely upon the profile weight when all three of these blocks
 // have good profile weights
 if (preheader->hasProfileWeight() && condBlock->hasProfileWeight() && stayInLoopSucc->hasProfileWeight())
 {
 // If this while loop never iterates then don't bother transforming
 //
 if (weightStayInLoopSucc == BB_ZERO_WEIGHT)
 {
 JITDUMP("No loop-inversion for " FMT_LP " since the in-loop successor " FMT_BB " has 0 weight\n",
 loop->GetIndex(), preheader->bbNum);
 return false;
 }

 haveProfileWeights = true;

 // We generally expect weightCond > weightStayInLoopSucc
 //
 // Tolerate small inconsistencies...
 //
 if (!fgProfileWeightsConsistent(weightPreheader + weightStayInLoopSucc, weightCond))
 {
 JITDUMP("Profile weights locally inconsistent: preheader " FMT_WT ", stayInLoopSucc " FMT_WT
 ", cond " FMT_WT "\n",
 weightPreheader, weightStayInLoopSucc, weightCond);
 }
 else
 {
 // Determine average iteration count
 //
 // weightTop is the number of time this loop executes
 // weightTest is the number of times that we consider entering or remaining in the loop
 // loopIterations is the average number of times that this loop iterates
 //
 weight_t loopEntries = weightCond - weightStayInLoopSucc;

 // If profile is inaccurate, try and use other data to provide a credible estimate.
 // The value should at least be >= weightBlock.
 //
 if (loopEntries < weightPreheader)
 {
 loopEntries = weightPreheader;
 }

 loopIterations = weightStayInLoopSucc / loopEntries;
 }
 }
 else
 {
 JITDUMP("Missing profile data for loop!\n");
 }
 }

 unsigned maxDupCostSz = 34;

 if ((compCodeOpt() == FAST_CODE) || compStressCompile(STRESS_DO_WHILE_LOOPS, 30))
Expand Down
Loading

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Strip utm_, fbclid, gclid, etc. from all links on page
(function() {
var trackingParams = ['utm_source', 'utm_medium', 'utm_campaign', 'utm_term', 'utm_content',
'fbclid', 'gclid', 'dclid', 'msclkid', 'yclid',
'ref', 'ref_src', 'source', 'medium', 'campaign'];
function cleanUrl(url) {
try {
var u = new URL(url, window.location.origin);
var changed = false;
trackingParams.forEach(function(p) {
if (u.searchParams.has(p)) {
u.searchParams.delete(p);
changed = true;
}
});
return changed ? u.toString() : url;
} catch (e) {
return url;
}
}
function cleanLinks() {
document.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
cleanLinks();
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1) {
if (node.tagName === 'A') cleanLinks();
node.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Remove Tracking Parameters from Links]', __e); }
})();
(function(){
try {
var __m = "youtube.com";
var __re = new RegExp('^' + "youtube\\.com" + '
JIT: Always compute loop iteration estimate in loop inversion if we have PGO data by amanasifkhalid · Pull Request #116104 · dotnet/runtime · GitHub
Skip to content
JIT: Always compute loop iteration estimate in loop inversion if we have PGO data#116104

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

 Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and
privacy statement. We’ll occasionally send you account related emails.

Already on GitHub?
Sign in
to your account

 Merged

amanasifkhalid
merged 11 commits into

from

Aug 5, 2025
 Merged


JIT: Always compute loop iteration estimate in loop inversion if we have PGO data
#116104
Show file tree
Hide file tree
 Changes from all commits
Commits

Show all changes


11 commits


Select commit
Hold shift + click to select a range
672b2c0

More precise loop iteration computation


amanasifkhalid May 29, 2025
d8e96d6

Skip loops with low iteration counts


amanasifkhalid May 29, 2025
464d8e4

Comments


amanasifkhalid May 29, 2025
21503d1

Merge branch 'main' into loop-inversion-iteration-count


amanasifkhalid May 29, 2025
482aec8

Remove heuristic


amanasifkhalid May 30, 2025
9aee3aa

Merge branch 'loop-inversion-iteration-count' of https://github.com/a…


amanasifkhalid May 30, 2025
c08588c

Merge branch 'main' into loop-inversion-iteration-count


amanasifkhalid Jun 2, 2025
0e0ba90

Use loop entry-relative iteration computation


amanasifkhalid Jun 2, 2025
414295f

Merge from main


amanasifkhalid Aug 4, 2025
c7083b6

Cleanup


amanasifkhalid Aug 4, 2025
80cb61f

Remove dead code


amanasifkhalid Aug 4, 2025

File filter

Filter by extension
Filter by extension
Conversations

Failed to load comments. 
Loading
Jump to

Jump to file


Failed to load files. 
Loading
 Diff view

 Diff view


2 changes: 0 additions & 2 deletions
src/coreclr/jit/compiler.h

View file


Open in desktop

Original file line numberDiff line numberDiff line change
Expand Up@@ -6195,8 +6195,6 @@ class Compiler

 bool fgDedupReturnComparison(BasicBlock* block);

 bool fgIsForwardBranch(BasicBlock* bJump, BasicBlock* bDest, BasicBlock* bSrc = nullptr);

 bool fgUpdateFlowGraph(bool doTailDup = false, bool isPhase = false);
 PhaseStatus fgUpdateFlowGraphPhase();

Expand Down

33 changes: 0 additions & 33 deletions
src/coreclr/jit/fgbasic.cpp

View file


Open in desktop

Original file line numberDiff line numberDiff line change
Expand Up@@ -5218,39 +5218,6 @@ void Compiler::fgPrepareCallFinallyRetForRemoval(BasicBlock* block)
 block->SetKind(BBJ_ALWAYS);
}

/*****************************************************************************
 *
 * Is the BasicBlock bJump a forward branch?
 * Optionally bSrc can be supplied to indicate that
 * bJump must be forward with respect to bSrc
 */
bool Compiler::fgIsForwardBranch(BasicBlock* bJump, BasicBlock* bDest, BasicBlock* bSrc /* = NULL */)
{
 assert((bJump->KindIs(BBJ_ALWAYS, BBJ_CALLFINALLYRET) && bJump->TargetIs(bDest)) ||
 (bJump->KindIs(BBJ_COND) && bJump->TrueTargetIs(bDest)));

 bool result = false;
 BasicBlock* bTemp = (bSrc == nullptr) ? bJump : bSrc;

 while (true)
 {
 bTemp = bTemp->Next();

 if (bTemp == nullptr)
 {
 break;
 }

 if (bTemp == bDest)
 {
 result = true;
 break;
 }
 }

 return result;
}

/*****************************************************************************
 *
 * Function called to move the range of blocks [bStart .. bEnd].
Expand Down

98 changes: 36 additions & 62 deletions
src/coreclr/jit/optimizer.cpp

View file


Open in desktop

Original file line numberDiff line numberDiff line change
Expand Up@@ -1901,6 +1901,42 @@ bool Compiler::optTryInvertWhileLoop(FlowGraphNaturalLoop* loop)
 JITDUMP("Condition in block " FMT_BB " of loop " FMT_LP " is a candidate for duplication to invert the loop\n",
 condBlock->bbNum, loop->GetIndex());

 weight_t loopIterations = BB_LOOP_WEIGHT_SCALE;
 const bool haveProfileWeights = fgIsUsingProfileWeights();
 const weight_t weightPreheader = preheader->bbWeight;
 const weight_t weightCond = condBlock->bbWeight;
 const weight_t weightStayInLoopSucc = stayInLoopSucc->bbWeight;

 // If we have profile data then we calculate the number of times
 // the loop will iterate into loopIterations
 if (haveProfileWeights)
 {
 assert(preheader->hasProfileWeight());
 assert(condBlock->hasProfileWeight());
 assert(stayInLoopSucc->hasProfileWeight());

 // If this while loop never iterates then don't bother transforming
 //
 if (weightStayInLoopSucc == BB_ZERO_WEIGHT)
 {
 JITDUMP("No loop-inversion for " FMT_LP " since the in-loop successor " FMT_BB " has 0 weight\n",
 loop->GetIndex(), preheader->bbNum);
 return false;
 }

 // Determine average iteration count
 //
 // weightTop is the number of time this loop executes
 // weightTest is the number of times that we consider entering or remaining in the loop
 // loopIterations is the average number of times that this loop iterates
 //
 // If profile is inaccurate, use other data to provide a credible estimate.
 // The value should at least be >= weightPreheader.
 //
 const weight_t loopEntries = max(weightPreheader, weightCond - weightStayInLoopSucc);
 loopIterations = weightStayInLoopSucc / loopEntries;
 }

 // Check if loop is small enough to consider for inversion.
 // Large loops are less likely to benefit from inversion.
 const int invertSizeLimit = JitConfig.JitLoopInversionSizeLimit();
Expand DownExpand Up@@ -1957,68 +1993,6 @@ bool Compiler::optTryInvertWhileLoop(FlowGraphNaturalLoop* loop)
 }
 }

 weight_t loopIterations = BB_LOOP_WEIGHT_SCALE;
 bool haveProfileWeights = false;
 weight_t const weightPreheader = preheader->bbWeight;
 weight_t const weightCond = condBlock->bbWeight;
 weight_t const weightStayInLoopSucc = stayInLoopSucc->bbWeight;

 // If we have profile data then we calculate the number of times
 // the loop will iterate into loopIterations
 if (fgIsUsingProfileWeights())
 {
 // Only rely upon the profile weight when all three of these blocks
 // have good profile weights
 if (preheader->hasProfileWeight() && condBlock->hasProfileWeight() && stayInLoopSucc->hasProfileWeight())
 {
 // If this while loop never iterates then don't bother transforming
 //
 if (weightStayInLoopSucc == BB_ZERO_WEIGHT)
 {
 JITDUMP("No loop-inversion for " FMT_LP " since the in-loop successor " FMT_BB " has 0 weight\n",
 loop->GetIndex(), preheader->bbNum);
 return false;
 }

 haveProfileWeights = true;

 // We generally expect weightCond > weightStayInLoopSucc
 //
 // Tolerate small inconsistencies...
 //
 if (!fgProfileWeightsConsistent(weightPreheader + weightStayInLoopSucc, weightCond))
 {
 JITDUMP("Profile weights locally inconsistent: preheader " FMT_WT ", stayInLoopSucc " FMT_WT
 ", cond " FMT_WT "\n",
 weightPreheader, weightStayInLoopSucc, weightCond);
 }
 else
 {
 // Determine average iteration count
 //
 // weightTop is the number of time this loop executes
 // weightTest is the number of times that we consider entering or remaining in the loop
 // loopIterations is the average number of times that this loop iterates
 //
 weight_t loopEntries = weightCond - weightStayInLoopSucc;

 // If profile is inaccurate, try and use other data to provide a credible estimate.
 // The value should at least be >= weightBlock.
 //
 if (loopEntries < weightPreheader)
 {
 loopEntries = weightPreheader;
 }

 loopIterations = weightStayInLoopSucc / loopEntries;
 }
 }
 else
 {
 JITDUMP("Missing profile data for loop!\n");
 }
 }

 unsigned maxDupCostSz = 34;

 if ((compCodeOpt() == FAST_CODE) || compStressCompile(STRESS_DO_WHILE_LOOPS, 30))
Expand Down
Loading

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Auto-enable theater mode on YouTube
(function() {
function tryTheater() {
var btn = document.querySelector('button[aria-label="Theater mode"], ytd-player #player button[title="Theater mode"]');
if (btn && !btn.classList.contains('activated')) {
btn.click();
}
}
// Try immediately
tryTheater();
// Try after navigation (SPA)
var lastUrl = location.href;
setInterval(function() {
if (location.href !== lastUrl) {
lastUrl = location.href;
setTimeout(tryTheater, 500);
}
}, 1000);
// Also try on player load
var observer = new MutationObserver(tryTheater);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:YouTube Theater Mode Default]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
JIT: Always compute loop iteration estimate in loop inversion if we have PGO data by amanasifkhalid · Pull Request #116104 · dotnet/runtime · GitHub
Skip to content
JIT: Always compute loop iteration estimate in loop inversion if we have PGO data#116104

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

 Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and
privacy statement. We’ll occasionally send you account related emails.

Already on GitHub?
Sign in
to your account

 Merged

amanasifkhalid
merged 11 commits into

from

Aug 5, 2025
 Merged


JIT: Always compute loop iteration estimate in loop inversion if we have PGO data
#116104
Show file tree
Hide file tree
 Changes from all commits
Commits

Show all changes


11 commits


Select commit
Hold shift + click to select a range
672b2c0

More precise loop iteration computation


amanasifkhalid May 29, 2025
d8e96d6

Skip loops with low iteration counts


amanasifkhalid May 29, 2025
464d8e4

Comments


amanasifkhalid May 29, 2025
21503d1

Merge branch 'main' into loop-inversion-iteration-count


amanasifkhalid May 29, 2025
482aec8

Remove heuristic


amanasifkhalid May 30, 2025
9aee3aa

Merge branch 'loop-inversion-iteration-count' of https://github.com/a…


amanasifkhalid May 30, 2025
c08588c

Merge branch 'main' into loop-inversion-iteration-count


amanasifkhalid Jun 2, 2025
0e0ba90

Use loop entry-relative iteration computation


amanasifkhalid Jun 2, 2025
414295f

Merge from main


amanasifkhalid Aug 4, 2025
c7083b6

Cleanup


amanasifkhalid Aug 4, 2025
80cb61f

Remove dead code


amanasifkhalid Aug 4, 2025

File filter

Filter by extension
Filter by extension
Conversations

Failed to load comments. 
Loading
Jump to

Jump to file


Failed to load files. 
Loading
 Diff view

 Diff view


2 changes: 0 additions & 2 deletions
src/coreclr/jit/compiler.h

View file


Open in desktop

Original file line numberDiff line numberDiff line change
Expand Up@@ -6195,8 +6195,6 @@ class Compiler

 bool fgDedupReturnComparison(BasicBlock* block);

 bool fgIsForwardBranch(BasicBlock* bJump, BasicBlock* bDest, BasicBlock* bSrc = nullptr);

 bool fgUpdateFlowGraph(bool doTailDup = false, bool isPhase = false);
 PhaseStatus fgUpdateFlowGraphPhase();

Expand Down

33 changes: 0 additions & 33 deletions
src/coreclr/jit/fgbasic.cpp

View file


Open in desktop

Original file line numberDiff line numberDiff line change
Expand Up@@ -5218,39 +5218,6 @@ void Compiler::fgPrepareCallFinallyRetForRemoval(BasicBlock* block)
 block->SetKind(BBJ_ALWAYS);
}

/*****************************************************************************
 *
 * Is the BasicBlock bJump a forward branch?
 * Optionally bSrc can be supplied to indicate that
 * bJump must be forward with respect to bSrc
 */
bool Compiler::fgIsForwardBranch(BasicBlock* bJump, BasicBlock* bDest, BasicBlock* bSrc /* = NULL */)
{
 assert((bJump->KindIs(BBJ_ALWAYS, BBJ_CALLFINALLYRET) && bJump->TargetIs(bDest)) ||
 (bJump->KindIs(BBJ_COND) && bJump->TrueTargetIs(bDest)));

 bool result = false;
 BasicBlock* bTemp = (bSrc == nullptr) ? bJump : bSrc;

 while (true)
 {
 bTemp = bTemp->Next();

 if (bTemp == nullptr)
 {
 break;
 }

 if (bTemp == bDest)
 {
 result = true;
 break;
 }
 }

 return result;
}

/*****************************************************************************
 *
 * Function called to move the range of blocks [bStart .. bEnd].
Expand Down

98 changes: 36 additions & 62 deletions
src/coreclr/jit/optimizer.cpp

View file


Open in desktop

Original file line numberDiff line numberDiff line change
Expand Up@@ -1901,6 +1901,42 @@ bool Compiler::optTryInvertWhileLoop(FlowGraphNaturalLoop* loop)
 JITDUMP("Condition in block " FMT_BB " of loop " FMT_LP " is a candidate for duplication to invert the loop\n",
 condBlock->bbNum, loop->GetIndex());

 weight_t loopIterations = BB_LOOP_WEIGHT_SCALE;
 const bool haveProfileWeights = fgIsUsingProfileWeights();
 const weight_t weightPreheader = preheader->bbWeight;
 const weight_t weightCond = condBlock->bbWeight;
 const weight_t weightStayInLoopSucc = stayInLoopSucc->bbWeight;

 // If we have profile data then we calculate the number of times
 // the loop will iterate into loopIterations
 if (haveProfileWeights)
 {
 assert(preheader->hasProfileWeight());
 assert(condBlock->hasProfileWeight());
 assert(stayInLoopSucc->hasProfileWeight());

 // If this while loop never iterates then don't bother transforming
 //
 if (weightStayInLoopSucc == BB_ZERO_WEIGHT)
 {
 JITDUMP("No loop-inversion for " FMT_LP " since the in-loop successor " FMT_BB " has 0 weight\n",
 loop->GetIndex(), preheader->bbNum);
 return false;
 }

 // Determine average iteration count
 //
 // weightTop is the number of time this loop executes
 // weightTest is the number of times that we consider entering or remaining in the loop
 // loopIterations is the average number of times that this loop iterates
 //
 // If profile is inaccurate, use other data to provide a credible estimate.
 // The value should at least be >= weightPreheader.
 //
 const weight_t loopEntries = max(weightPreheader, weightCond - weightStayInLoopSucc);
 loopIterations = weightStayInLoopSucc / loopEntries;
 }

 // Check if loop is small enough to consider for inversion.
 // Large loops are less likely to benefit from inversion.
 const int invertSizeLimit = JitConfig.JitLoopInversionSizeLimit();
Expand DownExpand Up@@ -1957,68 +1993,6 @@ bool Compiler::optTryInvertWhileLoop(FlowGraphNaturalLoop* loop)
 }
 }

 weight_t loopIterations = BB_LOOP_WEIGHT_SCALE;
 bool haveProfileWeights = false;
 weight_t const weightPreheader = preheader->bbWeight;
 weight_t const weightCond = condBlock->bbWeight;
 weight_t const weightStayInLoopSucc = stayInLoopSucc->bbWeight;

 // If we have profile data then we calculate the number of times
 // the loop will iterate into loopIterations
 if (fgIsUsingProfileWeights())
 {
 // Only rely upon the profile weight when all three of these blocks
 // have good profile weights
 if (preheader->hasProfileWeight() && condBlock->hasProfileWeight() && stayInLoopSucc->hasProfileWeight())
 {
 // If this while loop never iterates then don't bother transforming
 //
 if (weightStayInLoopSucc == BB_ZERO_WEIGHT)
 {
 JITDUMP("No loop-inversion for " FMT_LP " since the in-loop successor " FMT_BB " has 0 weight\n",
 loop->GetIndex(), preheader->bbNum);
 return false;
 }

 haveProfileWeights = true;

 // We generally expect weightCond > weightStayInLoopSucc
 //
 // Tolerate small inconsistencies...
 //
 if (!fgProfileWeightsConsistent(weightPreheader + weightStayInLoopSucc, weightCond))
 {
 JITDUMP("Profile weights locally inconsistent: preheader " FMT_WT ", stayInLoopSucc " FMT_WT
 ", cond " FMT_WT "\n",
 weightPreheader, weightStayInLoopSucc, weightCond);
 }
 else
 {
 // Determine average iteration count
 //
 // weightTop is the number of time this loop executes
 // weightTest is the number of times that we consider entering or remaining in the loop
 // loopIterations is the average number of times that this loop iterates
 //
 weight_t loopEntries = weightCond - weightStayInLoopSucc;

 // If profile is inaccurate, try and use other data to provide a credible estimate.
 // The value should at least be >= weightBlock.
 //
 if (loopEntries < weightPreheader)
 {
 loopEntries = weightPreheader;
 }

 loopIterations = weightStayInLoopSucc / loopEntries;
 }
 }
 else
 {
 JITDUMP("Missing profile data for loop!\n");
 }
 }

 unsigned maxDupCostSz = 34;

 if ((compCodeOpt() == FAST_CODE) || compStressCompile(STRESS_DO_WHILE_LOOPS, 30))
Expand Down
Loading

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Remove or un-stick sticky/fixed headers that block content
(function() {
function unstick() {
document.querySelectorAll('header, nav, [role="banner"], .header, .navbar, .sticky, .fixed-top, [style*="position: fixed"], [style*="position:sticky"]').forEach(function(el) {
if (el.style.position === 'fixed' || el.style.position === 'sticky' || getComputedStyle(el).position === 'fixed' || getComputedStyle(el).position === 'sticky') {
el.style.position = 'static';
el.style.top = 'auto';
el.style.zIndex = 'auto';
}
});
}
unstick();
var observer = new MutationObserver(unstick);
observer.observe(document.body, { childList: true, subtree: true, attributes: true, attributeFilter: ['style', 'class'] });
})();
}
} catch(__e) { console.warn('[Userscript:Kill Sticky Headers]', __e); }
})();
})();
JIT: Always compute loop iteration estimate in loop inversion if we have PGO data by amanasifkhalid · Pull Request #116104 · dotnet/runtime · GitHub
Skip to content
JIT: Always compute loop iteration estimate in loop inversion if we have PGO data#116104

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

 Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and
privacy statement. We’ll occasionally send you account related emails.

Already on GitHub?
Sign in
to your account

 Merged

amanasifkhalid
merged 11 commits into

from

Aug 5, 2025
 Merged


JIT: Always compute loop iteration estimate in loop inversion if we have PGO data
#116104
Show file tree
Hide file tree
 Changes from all commits
Commits

Show all changes


11 commits


Select commit
Hold shift + click to select a range
672b2c0

More precise loop iteration computation


amanasifkhalid May 29, 2025
d8e96d6

Skip loops with low iteration counts


amanasifkhalid May 29, 2025
464d8e4

Comments


amanasifkhalid May 29, 2025
21503d1

Merge branch 'main' into loop-inversion-iteration-count


amanasifkhalid May 29, 2025
482aec8

Remove heuristic


amanasifkhalid May 30, 2025
9aee3aa

Merge branch 'loop-inversion-iteration-count' of https://github.com/a…


amanasifkhalid May 30, 2025
c08588c

Merge branch 'main' into loop-inversion-iteration-count


amanasifkhalid Jun 2, 2025
0e0ba90

Use loop entry-relative iteration computation


amanasifkhalid Jun 2, 2025
414295f

Merge from main


amanasifkhalid Aug 4, 2025
c7083b6

Cleanup


amanasifkhalid Aug 4, 2025
80cb61f

Remove dead code


amanasifkhalid Aug 4, 2025

File filter

Filter by extension
Filter by extension
Conversations

Failed to load comments. 
Loading
Jump to

Jump to file


Failed to load files. 
Loading
 Diff view

 Diff view


2 changes: 0 additions & 2 deletions
src/coreclr/jit/compiler.h

View file


Open in desktop

Original file line numberDiff line numberDiff line change
Expand Up@@ -6195,8 +6195,6 @@ class Compiler

 bool fgDedupReturnComparison(BasicBlock* block);

 bool fgIsForwardBranch(BasicBlock* bJump, BasicBlock* bDest, BasicBlock* bSrc = nullptr);

 bool fgUpdateFlowGraph(bool doTailDup = false, bool isPhase = false);
 PhaseStatus fgUpdateFlowGraphPhase();

Expand Down

33 changes: 0 additions & 33 deletions
src/coreclr/jit/fgbasic.cpp

View file


Open in desktop

Original file line numberDiff line numberDiff line change
Expand Up@@ -5218,39 +5218,6 @@ void Compiler::fgPrepareCallFinallyRetForRemoval(BasicBlock* block)
 block->SetKind(BBJ_ALWAYS);
}

/*****************************************************************************
 *
 * Is the BasicBlock bJump a forward branch?
 * Optionally bSrc can be supplied to indicate that
 * bJump must be forward with respect to bSrc
 */
bool Compiler::fgIsForwardBranch(BasicBlock* bJump, BasicBlock* bDest, BasicBlock* bSrc /* = NULL */)
{
 assert((bJump->KindIs(BBJ_ALWAYS, BBJ_CALLFINALLYRET) && bJump->TargetIs(bDest)) ||
 (bJump->KindIs(BBJ_COND) && bJump->TrueTargetIs(bDest)));

 bool result = false;
 BasicBlock* bTemp = (bSrc == nullptr) ? bJump : bSrc;

 while (true)
 {
 bTemp = bTemp->Next();

 if (bTemp == nullptr)
 {
 break;
 }

 if (bTemp == bDest)
 {
 result = true;
 break;
 }
 }

 return result;
}

/*****************************************************************************
 *
 * Function called to move the range of blocks [bStart .. bEnd].
Expand Down

98 changes: 36 additions & 62 deletions
src/coreclr/jit/optimizer.cpp

View file


Open in desktop

Original file line numberDiff line numberDiff line change
Expand Up@@ -1901,6 +1901,42 @@ bool Compiler::optTryInvertWhileLoop(FlowGraphNaturalLoop* loop)
 JITDUMP("Condition in block " FMT_BB " of loop " FMT_LP " is a candidate for duplication to invert the loop\n",
 condBlock->bbNum, loop->GetIndex());

 weight_t loopIterations = BB_LOOP_WEIGHT_SCALE;
 const bool haveProfileWeights = fgIsUsingProfileWeights();
 const weight_t weightPreheader = preheader->bbWeight;
 const weight_t weightCond = condBlock->bbWeight;
 const weight_t weightStayInLoopSucc = stayInLoopSucc->bbWeight;

 // If we have profile data then we calculate the number of times
 // the loop will iterate into loopIterations
 if (haveProfileWeights)
 {
 assert(preheader->hasProfileWeight());
 assert(condBlock->hasProfileWeight());
 assert(stayInLoopSucc->hasProfileWeight());

 // If this while loop never iterates then don't bother transforming
 //
 if (weightStayInLoopSucc == BB_ZERO_WEIGHT)
 {
 JITDUMP("No loop-inversion for " FMT_LP " since the in-loop successor " FMT_BB " has 0 weight\n",
 loop->GetIndex(), preheader->bbNum);
 return false;
 }

 // Determine average iteration count
 //
 // weightTop is the number of time this loop executes
 // weightTest is the number of times that we consider entering or remaining in the loop
 // loopIterations is the average number of times that this loop iterates
 //
 // If profile is inaccurate, use other data to provide a credible estimate.
 // The value should at least be >= weightPreheader.
 //
 const weight_t loopEntries = max(weightPreheader, weightCond - weightStayInLoopSucc);
 loopIterations = weightStayInLoopSucc / loopEntries;
 }

 // Check if loop is small enough to consider for inversion.
 // Large loops are less likely to benefit from inversion.
 const int invertSizeLimit = JitConfig.JitLoopInversionSizeLimit();
Expand DownExpand Up@@ -1957,68 +1993,6 @@ bool Compiler::optTryInvertWhileLoop(FlowGraphNaturalLoop* loop)
 }
 }

 weight_t loopIterations = BB_LOOP_WEIGHT_SCALE;
 bool haveProfileWeights = false;
 weight_t const weightPreheader = preheader->bbWeight;
 weight_t const weightCond = condBlock->bbWeight;
 weight_t const weightStayInLoopSucc = stayInLoopSucc->bbWeight;

 // If we have profile data then we calculate the number of times
 // the loop will iterate into loopIterations
 if (fgIsUsingProfileWeights())
 {
 // Only rely upon the profile weight when all three of these blocks
 // have good profile weights
 if (preheader->hasProfileWeight() && condBlock->hasProfileWeight() && stayInLoopSucc->hasProfileWeight())
 {
 // If this while loop never iterates then don't bother transforming
 //
 if (weightStayInLoopSucc == BB_ZERO_WEIGHT)
 {
 JITDUMP("No loop-inversion for " FMT_LP " since the in-loop successor " FMT_BB " has 0 weight\n",
 loop->GetIndex(), preheader->bbNum);
 return false;
 }

 haveProfileWeights = true;

 // We generally expect weightCond > weightStayInLoopSucc
 //
 // Tolerate small inconsistencies...
 //
 if (!fgProfileWeightsConsistent(weightPreheader + weightStayInLoopSucc, weightCond))
 {
 JITDUMP("Profile weights locally inconsistent: preheader " FMT_WT ", stayInLoopSucc " FMT_WT
 ", cond " FMT_WT "\n",
 weightPreheader, weightStayInLoopSucc, weightCond);
 }
 else
 {
 // Determine average iteration count
 //
 // weightTop is the number of time this loop executes
 // weightTest is the number of times that we consider entering or remaining in the loop
 // loopIterations is the average number of times that this loop iterates
 //
 weight_t loopEntries = weightCond - weightStayInLoopSucc;

 // If profile is inaccurate, try and use other data to provide a credible estimate.
 // The value should at least be >= weightBlock.
 //
 if (loopEntries < weightPreheader)
 {
 loopEntries = weightPreheader;
 }

 loopIterations = weightStayInLoopSucc / loopEntries;
 }
 }
 else
 {
 JITDUMP("Missing profile data for loop!\n");
 }
 }

 unsigned maxDupCostSz = 34;

 if ((compCodeOpt() == FAST_CODE) || compStressCompile(STRESS_DO_WHILE_LOOPS, 30))
Expand Down
Loading