wip

wip2

wip3

Author: ikpil

src/Box2D.NET/B2CTZs.cs

@@ -2,12 +2,80 @@
 // SPDX-FileCopyrightText: 2025 Ikpil Choi(ikpil@naver.com)
 // SPDX-License-Identifier: MIT
 
+using System;
 using System.Runtime.CompilerServices;
 
 namespace Box2D.NET
 {
     public static class B2CTZs
     {
+        // De Bruijn magic constant and lookup table
+        private static readonly byte[] SampleMultiplyDeBruijnBitPosition = new byte[32]
+        {
+            0, 1, 28, 2, 29, 14, 24, 3,
+            30, 22, 20, 15, 25, 17, 4, 8,
+            31, 27, 13, 23, 21, 19, 16, 7,
+            26, 12, 18, 6, 11, 5, 10, 9
+        };
+
+        private static readonly byte[] SampleMultiplyDeBruijnBitPosition64 = new byte[64]
+        {
+            63, 0, 1, 52, 2, 6, 53, 26, 3, 37, 40, 7, 33, 54, 47, 27,
+            61, 4, 38, 45, 43, 41, 21, 8, 23, 34, 58, 55, 48, 17, 28, 10,
+            62, 51, 5, 25, 36, 39, 32, 46, 60, 44, 42, 20, 22, 57, 16, 9,
+            50, 24, 35, 31, 59, 19, 56, 15, 49, 30, 18, 14, 29, 13, 12, 11
+        };
+
+        private static readonly byte[] SampleClzTable = new byte[32]
+        {
+            31, 22, 30, 21, 18, 10, 29, 2,
+            20, 17, 15, 13, 9, 6, 28, 1,
+            23, 19, 11, 3, 16, 14, 7, 24,
+            12, 4, 8, 25, 5, 26, 27, 0
+        };
+
+
+        // uint에 대해 trailing zero count (CTZ)
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint b2CTZ32_DeRrujin(uint block)
+        {
+            if (block == 0) return 32;
+        
+            // isolate lowest set bit and multiply
+            uint idx = (uint)((block & -block) * 0x077CB531u) >> 27;
+            return SampleMultiplyDeBruijnBitPosition[idx];
+        }
+
+        // uint에 대해 leading zero count (CLZ)
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint b2CLZ32(uint block)
+        {
+            if (block == 0) return 32;
+
+            block |= block >> 1;
+            block |= block >> 2;
+            block |= block >> 4;
+            block |= block >> 8;
+            block |= block >> 16;
+
+            uint idx = (block * 0x07C4ACDDu) >> 27;
+            return SampleClzTable[idx];
+        }
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint b2CTZ64_DeBrujin(ulong x)
+        {
+            if (x == 0)
+                return 64;
+        
+            // x & -x : ulong 음수 연산 불가 → ~x + 1 사용
+            ulong isolated = x & (~x + 1UL);
+        
+            int index = (int)((isolated * 0x045FBAC7992A70DAUL) >> 58);
+        
+            return SampleMultiplyDeBruijnBitPosition64[index];
+        }
+        
         // uint에 대해 trailing zero count (CTZ)
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static uint b2CTZ32(uint block)
@@ -25,7 +93,7 @@ public static uint b2CTZ32(uint block)
 
         // uint에 대해 leading zero count (CLZ)
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static uint b2CLZ32(uint value)
+        public static uint b2CLZ32_Old(uint value)
         {
             if (value == 0) return 32;
             uint count = 0;
@@ -54,6 +122,7 @@ public static uint b2CTZ64(ulong block)
             return count;
         }
 
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static int b2PopCount64(ulong block)
         {

tools/Box2D.NET.Benchmark/Box2D.NET.Core.Benchmark/BitOpBenchmarks.cs

@@ -0,0 +1,137 @@
+using System;
+using System.Numerics;
+using BenchmarkDotNet.Attributes;
+
+namespace Box2D.NET.Benchmark.Box2D.NET.Core.Benchmark;
+
+/*
+
+BenchmarkDotNet v0.15.2, Windows 11 (10.0.26100.4652/24H2/2024Update/HudsonValley)
+AMD Ryzen 7 5800X 3.80GHz, 1 CPU, 16 logical and 8 physical cores
+.NET SDK 9.0.101
+  [Host]     : .NET 8.0.15 (8.0.1525.16413), X64 RyuJIT AVX2
+  DefaultJob : .NET 8.0.15 (8.0.1525.16413), X64 RyuJIT AVX2
+
+
+| Method              | Mean      | Error     | StdDev    | Allocated |
+|-------------------- |----------:|----------:|----------:|----------:|
+| CTZ32               |  4.404 us | 0.0198 us | 0.0166 us |         - |
+| CTZ32_DeBrujin      |  6.896 us | 0.1373 us | 0.1925 us |         - |
+| CTZ32_BitOperations |  6.544 us | 0.0325 us | 0.0272 us |         - |
+| CLZ32               | 13.590 us | 0.2677 us | 0.2749 us |         - |
+| CLZ32_BitOperations |  4.594 us | 0.0914 us | 0.1250 us |         - |
+| CLZ32_Old           | 13.247 us | 0.2080 us | 0.1844 us |         - |
+| CTZ64_DeBrujin      |  8.215 us | 0.1581 us | 0.2267 us |         - |
+| CTZ64_BitOperations |  6.577 us | 0.0437 us | 0.0408 us |         - |
+| CTZ64               |  4.474 us | 0.0727 us | 0.0680 us |         - |
+
+ */
+
+[MemoryDiagnoser]
+public class BitOpBenchmarks
+{
+    private const int Size = 10_000;
+    private static uint[] _randomU32;
+    private static ulong[] _randomU64;
+
+    [GlobalSetup]
+    public void Setup()
+    {
+        if (null == _randomU32)
+        {
+            // 고정 시드로 반복 가능한 테스트 
+            var rnd = new Random((int)(DateTime.Now.Ticks / TimeSpan.TicksPerSecond));
+            _randomU32 = new uint[Size];
+            _randomU64 = new ulong[Size];
+
+            for (int i = 0; i < Size; i++)
+            {
+                _randomU32[i] = (uint)rnd.Next() | 1; // 0 피해서 최소한 1
+                _randomU64[i] = ((ulong)(uint)rnd.Next() << 32) | (uint)rnd.Next() | 1UL;
+            }
+        }
+    }
+
+
+    [Benchmark]
+    public uint CTZ32()
+    {
+        uint sum = 0;
+        for (int i = 0; i < Size; i++)
+            sum += B2CTZs.b2CTZ32(_randomU32[i]);
+        return sum;
+    }
+
+    [Benchmark]
+    public uint CTZ32_DeBrujin()
+    {
+        uint sum = 0;
+        for (int i = 0; i < Size; i++)
+            sum += B2CTZs.b2CTZ32_DeRrujin(_randomU32[i]);
+        return sum;
+    }
+
+    [Benchmark]
+    public int CTZ32_BitOperations()
+    {
+        int sum = 0;
+        for (int i = 0; i < Size; i++)
+            sum += BitOperations.TrailingZeroCount(_randomU32[i]);
+        return sum;
+    }
+
+    [Benchmark]
+    public uint CLZ32()
+    {
+        uint sum = 0;
+        for (int i = 0; i < Size; i++)
+            sum += B2CTZs.b2CLZ32(_randomU32[i]);
+        return sum;
+    }
+
+    [Benchmark]
+    public int CLZ32_BitOperations()
+    {
+        int sum = 0;
+        for (int i = 0; i < Size; i++)
+            sum += BitOperations.LeadingZeroCount(_randomU32[i]);
+        return sum;
+    }
+
+
+    [Benchmark]
+    public uint CLZ32_Old()
+    {
+        uint sum = 0;
+        for (int i = 0; i < Size; i++)
+            sum += B2CTZs.b2CLZ32_Old(_randomU32[i]);
+        return sum;
+    }
+
+    [Benchmark]
+    public uint CTZ64_DeBrujin()
+    {
+        uint sum = 0;
+        for (int i = 0; i < Size; i++)
+            sum += B2CTZs.b2CTZ64_DeBrujin(_randomU64[i]);
+        return sum;
+    }
+
+    [Benchmark]
+    public int CTZ64_BitOperations()
+    {
+        int sum = 0;
+        for (int i = 0; i < Size; i++)
+            sum += BitOperations.TrailingZeroCount(_randomU64[i]);
+        return sum;
+    }
+
+    [Benchmark]
+    public uint CTZ64()
+    {
+        uint sum = 0;
+        for (int i = 0; i < Size; i++)
+            sum += B2CTZs.b2CTZ64(_randomU64[i]);
+        return sum;
+    }
+}