Skip to content

[MemDep] Optimize SortNonLocalDepInfoCache sorting strategy for large caches with few unsorted entries #143107

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
nikic merged 2 commits into from
Jul 25, 2025
Merged

[MemDep] Optimize SortNonLocalDepInfoCache sorting strategy for large caches with few unsorted entries #143107

Changes from 1 commit
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
c49a7e8
[MemDep] Optimize SortNonLocalDepInfoCache sorting strategy for large…
DingdWang Jun 26, 2025
fec951d
fix comments from nikic
DingdWang Jul 25, 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
48 changes: 28 additions & 20 deletions llvm/lib/Analysis/MemoryDependenceAnalysis.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -983,33 +983,41 @@ MemDepResult MemoryDependenceResults::getNonLocalInfoForBlock(
static void
SortNonLocalDepInfoCache(MemoryDependenceResults::NonLocalDepInfo &Cache,
unsigned NumSortedEntries) {
switch (Cache.size() - NumSortedEntries) {
case 0:
// done, no new entries.
break;
case 2: {
// Two new entries, insert the last one into place.
NonLocalDepEntry Val = Cache.back();
Cache.pop_back();
MemoryDependenceResults::NonLocalDepInfo::iterator Entry =
std::upper_bound(Cache.begin(), Cache.end() - 1, Val);
Cache.insert(Entry, Val);
[[fallthrough]];

// Output number of sorted entries and size of cache for each sort.
LLVM_DEBUG(dbgs() << "NumSortedEntries: " << NumSortedEntries
<< ", Cache.size: " << Cache.size() << "\n");
Copy link
Contributor

@nikic nikic Jul 25, 2025

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Please drop this debug output, it will be very spammy for anyone not specifically trying to optimize this code.

Copy link
Contributor Author

@DingdWang DingdWang Jul 25, 2025

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

done


// If only one entry, don't sort.
if (Cache.size() < 2)
return;

unsigned s = Cache.size() - NumSortedEntries;

// If the cache is already sorted, don't sort it again.
if (s == 0)
return;

// If no entry is sorted, sort the whole cache.
if (NumSortedEntries == 0) {
llvm::sort(Cache);
return;
}
case 1:
// One new entry, Just insert the new value at the appropriate position.
if (Cache.size() != 1) {

// If the number of unsorted entires is small and the cache size is big, use
Copy link
Contributor

@nikic nikic Jul 25, 2025

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Suggested change
// If the number of unsorted entires is small and the cache size is big, use
// If the number of unsorted entires is small and the cache size is big, using

Copy link
Contributor Author

@DingdWang DingdWang Jul 25, 2025

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

done

// insertion sort is faster. Here use Log2_32 to quickly choose the sort
// method.
if (s < Log2_32(Cache.size())) {
Copy link
Contributor Author

@DingdWang DingdWang Jun 26, 2025

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

The choice of using log2 here is based on empirical experience. The main goal is to have a relatively fast way to determine whether the number of unsorted entries is significantly smaller than the cache size. To tune this condition, I experimented with the following four options, and based on the timing results, using log2 proved to be the fastest. The benchmark results are as follows:

  1. s < NumSortedEntries: https://llvm-compile-time-tracker.com/compare.php?from=26f3f24a4f0a67eb23d255aba7a73a12bee1db11&to=e174118c88ee3d9d31fb3ed4e29b9ae2fcac46fa&stat=instructions%3Au
  2. s < Log2_32(Cache.size()) * llvm::numbers::ln2 / llvm::numbers::ln10: https://llvm-compile-time-tracker.com/compare.php?from=26f3f24a4f0a67eb23d255aba7a73a12bee1db11&to=9368621b42fa8b68e1e3081110f82ae9a5d57458&stat=instructions%3Au
  3. s < Log2_32(Cache.size()) * llvm::numbers::ln2: https://llvm-compile-time-tracker.com/compare.php?from=26f3f24a4f0a67eb23d255aba7a73a12bee1db11&to=19a8584d14dbb95b4a71a92a43da3a2c5d5e550a&stat=instructions%3Au
  4. s < Log2_32(Cache.size()): https://llvm-compile-time-tracker.com/compare.php?from=26f3f24a4f0a67eb23d255aba7a73a12bee1db11&to=0fa6bc6bdf1c9c5464e81970e973f2c43edac874&stat=instructions%3Au

while (s > 0) {
NonLocalDepEntry Val = Cache.back();
Cache.pop_back();
MemoryDependenceResults::NonLocalDepInfo::iterator Entry =
llvm::upper_bound(Cache, Val);
std::upper_bound(Cache.begin(), Cache.end() - s + 1, Val);
Cache.insert(Entry, Val);
s--;
}
break;
default:
// Added many values, do a full scale sort.
} else {
llvm::sort(Cache);
break;
}
}

Expand Down
Loading