Use Log2_64_Ceil to compute PowerOf2Ceil

[AtariDreams]

Instead of calling NextPowerOf2, which is only useful for constants,
we should call Log2_64_Ceil, which is faster because it uses compiler
intrinsics where supported.

[llvmbot]

@llvm/pr-subscribers-llvm-support

Changes

Instead of calling NextPowerOf2, we can use compiler intrinsics to do this faster.

---

Full diff: https://github.com/llvm/llvm-project/pull/67580.diff

1 Files Affected:

• (modified) llvm/include/llvm/Support/MathExtras.h (+4)

diff --git a/llvm/include/llvm/Support/MathExtras.h b/llvm/include/llvm/Support/MathExtras.h
index dc095941fdc8a9f..f592beee5ccffc2 100644
--- a/llvm/include/llvm/Support/MathExtras.h
+++ b/llvm/include/llvm/Support/MathExtras.h
@@ -361,7 +361,11 @@ constexpr inline uint64_t NextPowerOf2(uint64_t A) {
 inline uint64_t PowerOf2Ceil(uint64_t A) {
   if (!A)
     return 0;
+#if __has_builtin(__builtin_clzl)
+  return 1ULL << (64 - __builtin_clzl(A - 1));
+#else
   return NextPowerOf2(A - 1);
+#endif
 }
 
 /// Returns the next integer (mod 2**64) that is greater than or equal to

[AtariDreams]

@gysit thoughts on this? @MaskRay

[gysit]

@AtariDreams I am not really familiar with the reasoning behind the current solution. I would probably ping the original author of the function?

[AtariDreams]

@dcci Thoughts on this?

[MaskRay]

This is manual strength reduction. NextPowerOf2 is a complex operation whose original purpose isn't clear to me.

[AtariDreams]

This is manual strength reduction. NextPowerOf2 is a complex operation whose original purpose isn't clear to me.

The only thing NextPowerOf2 has doing for it is that it is constexpr but also like it's used in non constexpr places too but that is something for another PR to address

[AtariDreams]

@MaskRay Can we please merge this?

[AtariDreams]

@MaskRay Any updates?

[rilysh]

The current implemention of NextPowerOf2 seems to be the most portable way to achieve the power of 2, which is equivalent to int(pow(2, ceil(log2(x)))). Only noticeable difference to me is that in the PR implementation, if x > (UINT32_MAX + 1), the current NextPowerOf2 and PR changes of that function will yield different results.

[MaskRay]

The current implemention of NextPowerOf2 seems to be the most portable way to achieve the power of 2, which is equivalent to int(pow(2, ceil(log2(x)))). Only noticeable difference to me is that in the PR implementation, if x > (UINT32_MAX + 1), the current NextPowerOf2 and PR changes of that function will yield different results.

Thanks for catching this.

Minor correction, when the argument is larger than 2**63, NextPowerOf2(A - 1) returns 0 (reasonable) while UINT64_C(1) << 64-std::countl_zero(A-1) is undefined (the right operand is 0)

[AtariDreams]

Fixed!

[github-actions]

✅ With the latest revision this PR passed the C/C++ code formatter.

[AtariDreams]

@MaskRay All done and taken care of!