mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-18 03:51:19 -10:00
* Perf: BitOps.LeadingZeroCount * CR fix * CR fixes * Optimization * Revert * Confirmed fix * Simplify * Return int * Fixes * Simplify * CR fixes * CR fixes * Fix unit failure on Linux-musl x64 Debug * CR fixes * CR fixes * Cleanup Signed-off-by: dotnet-bot <[email protected]>
240 lines
8.7 KiB
C#
240 lines
8.7 KiB
C#
// Licensed to the .NET Foundation under one or more agreements.
|
|
// The .NET Foundation licenses this file to you under the MIT license.
|
|
// See the LICENSE file in the project root for more information.
|
|
|
|
using System.Runtime.CompilerServices;
|
|
using System.Runtime.InteropServices;
|
|
using System.Runtime.Intrinsics.X86;
|
|
|
|
using Internal.Runtime.CompilerServices;
|
|
|
|
// Some routines inspired by the Stanford Bit Twiddling Hacks by Sean Eron Anderson:
|
|
// http://graphics.stanford.edu/~seander/bithacks.html
|
|
|
|
namespace System
|
|
{
|
|
internal static class BitOps
|
|
{
|
|
// C# no-alloc optimization that directly wraps the data section of the dll (similar to string constants)
|
|
// https://github.com/dotnet/roslyn/pull/24621
|
|
|
|
private static ReadOnlySpan<byte> s_TrailingZeroCountDeBruijn => new byte[32]
|
|
{
|
|
00, 01, 28, 02, 29, 14, 24, 03,
|
|
30, 22, 20, 15, 25, 17, 04, 08,
|
|
31, 27, 13, 23, 21, 19, 16, 07,
|
|
26, 12, 18, 06, 11, 05, 10, 09
|
|
};
|
|
|
|
private static ReadOnlySpan<byte> s_Log2DeBruijn => new byte[32]
|
|
{
|
|
00, 09, 01, 10, 13, 21, 02, 29,
|
|
11, 14, 16, 18, 22, 25, 03, 30,
|
|
08, 12, 20, 28, 15, 17, 24, 07,
|
|
19, 27, 23, 06, 26, 05, 04, 31
|
|
};
|
|
|
|
/// <summary>
|
|
/// Count the number of trailing zero bits in an integer value.
|
|
/// Similar in behavior to the x86 instruction TZCNT.
|
|
/// </summary>
|
|
/// <param name="value">The value.</param>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public static int TrailingZeroCount(int value)
|
|
=> TrailingZeroCount((uint)value);
|
|
|
|
/// <summary>
|
|
/// Count the number of trailing zero bits in an integer value.
|
|
/// Similar in behavior to the x86 instruction TZCNT.
|
|
/// </summary>
|
|
/// <param name="value">The value.</param>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public static int TrailingZeroCount(uint value)
|
|
{
|
|
if (Bmi1.IsSupported)
|
|
{
|
|
// Note that TZCNT contract specifies 0->32
|
|
return (int)Bmi1.TrailingZeroCount(value);
|
|
}
|
|
|
|
// Software fallback has behavior 0->0, so special-case to match intrinsic path 0->32
|
|
if (value == 0)
|
|
{
|
|
return 32;
|
|
}
|
|
|
|
// uint.MaxValue >> 27 is always in range [0 - 31] so we use Unsafe.AddByteOffset to avoid bounds check
|
|
return Unsafe.AddByteOffset(
|
|
// Using deBruijn sequence, k=2, n=5 (2^5=32) : 0b_0000_0111_0111_1100_1011_0101_0011_0001u
|
|
ref MemoryMarshal.GetReference(s_TrailingZeroCountDeBruijn),
|
|
// long -> IntPtr cast on 32-bit platforms is expensive - it does overflow checks not needed here
|
|
(IntPtr)(int)(((uint)((value & -value) * 0x077CB531u)) >> 27)); // shift over long also expensive on 32-bit
|
|
}
|
|
|
|
/// <summary>
|
|
/// Count the number of trailing zero bits in a mask.
|
|
/// Similar in behavior to the x86 instruction TZCNT.
|
|
/// </summary>
|
|
/// <param name="value">The value.</param>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public static int TrailingZeroCount(long value)
|
|
=> TrailingZeroCount((ulong)value);
|
|
|
|
/// <summary>
|
|
/// Count the number of trailing zero bits in a mask.
|
|
/// Similar in behavior to the x86 instruction TZCNT.
|
|
/// </summary>
|
|
/// <param name="value">The value.</param>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public static int TrailingZeroCount(ulong value)
|
|
{
|
|
if (Bmi1.X64.IsSupported)
|
|
{
|
|
// Note that TZCNT contract specifies 0->64
|
|
return (int)Bmi1.X64.TrailingZeroCount(value);
|
|
}
|
|
|
|
uint lo = (uint)value;
|
|
|
|
if (lo == 0)
|
|
{
|
|
return 32 + TrailingZeroCount((uint)(value >> 32));
|
|
}
|
|
|
|
return TrailingZeroCount(lo);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Count the number of leading zero bits in a mask.
|
|
/// Similar in behavior to the x86 instruction LZCNT.
|
|
/// </summary>
|
|
/// <param name="value">The value.</param>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public static int LeadingZeroCount(uint value)
|
|
{
|
|
if (Lzcnt.IsSupported)
|
|
{
|
|
// Note that LZCNT contract specifies 0->32
|
|
return (int)Lzcnt.LeadingZeroCount(value);
|
|
}
|
|
|
|
// Software fallback has behavior 0->0, so special-case to match intrinsic path 0->32
|
|
if (value == 0)
|
|
{
|
|
return 32;
|
|
}
|
|
|
|
return 31 - Log2(value);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Count the number of leading zero bits in a mask.
|
|
/// Similar in behavior to the x86 instruction LZCNT.
|
|
/// </summary>
|
|
/// <param name="value">The value.</param>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public static int LeadingZeroCount(ulong value)
|
|
{
|
|
if (Lzcnt.X64.IsSupported)
|
|
{
|
|
// Note that LZCNT contract specifies 0->64
|
|
return (int)Lzcnt.X64.LeadingZeroCount(value);
|
|
}
|
|
|
|
uint hi = (uint)(value >> 32);
|
|
|
|
if (hi == 0)
|
|
{
|
|
return 32 + LeadingZeroCount((uint)value);
|
|
}
|
|
|
|
return LeadingZeroCount(hi);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns the integer (floor) log of the specified value, base 2.
|
|
/// Note that by convention, input value 0 returns 0 since Log(0) is undefined.
|
|
/// </summary>
|
|
/// <param name="value">The value.</param>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public static int Log2(uint value)
|
|
{
|
|
// value lzcnt actual expected
|
|
// ..0000 32 0 0 (by convention, guard clause)
|
|
// ..0001 31 31-31 0
|
|
// ..0010 30 31-30 1
|
|
// 0010.. 2 31-2 29
|
|
// 0100.. 1 31-1 30
|
|
// 1000.. 0 31-0 31
|
|
if (Lzcnt.IsSupported)
|
|
{
|
|
// Enforce conventional contract 0->0 (since Log(0) is undefined)
|
|
if (value == 0)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
// Note that LZCNT contract specifies 0->32
|
|
return 31 - (int)Lzcnt.LeadingZeroCount(value);
|
|
}
|
|
|
|
// Already has contract 0->0, without branching
|
|
return Log2SoftwareFallback(value);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns the integer (floor) log of the specified value, base 2.
|
|
/// Note that by convention, input value 0 returns 0 since Log(0) is undefined.
|
|
/// Does not incur branching.
|
|
/// </summary>
|
|
/// <param name="value">The value.</param>
|
|
private static int Log2SoftwareFallback(uint value)
|
|
{
|
|
// No AggressiveInlining due to large method size
|
|
|
|
value |= value >> 01;
|
|
value |= value >> 02;
|
|
value |= value >> 04;
|
|
value |= value >> 08;
|
|
value |= value >> 16;
|
|
|
|
// uint.MaxValue >> 27 is always in range [0 - 31] so we use Unsafe.AddByteOffset to avoid bounds check
|
|
return Unsafe.AddByteOffset(
|
|
// Using deBruijn sequence, k=2, n=5 (2^5=32) : 0b_0000_0111_1100_0100_1010_1100_1101_1101u
|
|
ref MemoryMarshal.GetReference(s_Log2DeBruijn),
|
|
// long -> IntPtr cast on 32-bit platforms is expensive - it does overflow checks not needed here
|
|
(IntPtr)(int)((value * 0x07C4ACDDu) >> 27));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns the integer (floor) log of the specified value, base 2.
|
|
/// Note that by convention, input value 0 returns 0 since Log(0) is undefined.
|
|
/// </summary>
|
|
/// <param name="value">The value.</param>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public static int Log2(ulong value)
|
|
{
|
|
if (Lzcnt.X64.IsSupported)
|
|
{
|
|
// Enforce conventional contract 0->0 (since Log(0) is undefined)
|
|
if (value == 0)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
// Note that LZCNT contract specifies 0->64
|
|
return 63 - (int)Lzcnt.X64.LeadingZeroCount(value);
|
|
}
|
|
|
|
uint hi = (uint)(value >> 32);
|
|
|
|
if (hi == 0)
|
|
{
|
|
return Log2((uint)value);
|
|
}
|
|
|
|
return 32 + Log2(hi);
|
|
}
|
|
}
|
|
}
|