Implementation

Author: artelk

.github/workflows/benchmark.yml

@@ -0,0 +1,28 @@
+# This workflow will build a .NET project
+# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-net
+
+name: Benchmark
+
+on:
+  workflow_dispatch:
+
+jobs:
+  benchmark:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v4
+    - name: Setup .NET
+      uses: actions/setup-dotnet@v4
+      with:
+        dotnet-version: 9.0.x
+
+    - name: Restore dependencies
+      run: dotnet restore FastFibCode.sln
+
+    - name: Build
+      run: dotnet build -c Release --no-restore
+
+    - name: Run Benchmark
+      run:  cd ./FastFibCode.Benchmark && dotnet run -c Release --no-build

.github/workflows/buildAndTest.yml

@@ -0,0 +1,31 @@
+# This workflow will build a .NET project
+# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-net
+
+name: Build & Test
+
+on:
+  push:
+    branches: [ "main" ]
+  pull_request:
+    branches: [ "main" ]
+  workflow_dispatch:
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v4
+    - name: Setup .NET
+      uses: actions/setup-dotnet@v4
+      with:
+        dotnet-version: 9.0.x
+
+    - name: Restore dependencies
+      run: dotnet restore FastFibCode.sln
+
+    - name: Build
+      run: dotnet build -c Release --no-restore
+
+    - name: Test
+      run: dotnet test -c Release --no-build --verbosity normal

.gitignore

@@ -0,0 +1,33 @@
+
+#Ignore thumbnails created by Windows
+Thumbs.db
+#Ignore files built by Visual Studio
+*.obj
+*.exe
+*.pdb
+*.user
+*.aps
+*.pch
+*.vspscc
+*_i.c
+*_p.c
+*.ncb
+*.suo
+*.tlb
+*.tlh
+*.bak
+*.cache
+*.ilk
+*.log
+[Bb]in
+[Dd]ebug*/
+*.lib
+*.sbr
+obj/
+[Rr]elease*/
+_ReSharper*/
+[Tt]est[Rr]esult*
+.vs/
+.idea/
+#Nuget packages folder
+packages/

FastFibCode.Benchmark/CompareWithEliasDelta.cs

@@ -0,0 +1,51 @@
+using BenchmarkDotNet.Attributes;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+
+namespace FastFibCode.Benchmark;
+
+public class CompareWithEliasDelta
+{
+    private static uint[] data = new uint[1_000_000];
+
+    [GlobalSetup]
+    public void GlobalSetup()
+    {
+        for (int i = 0; i < data.Length; i++)
+        {
+            data[i] = DistributionData.ExponentialDistributionRandom(1000_000);
+        }
+    }
+
+    [Benchmark(Baseline = true)]
+    public ulong EliasDeltaEncode()
+    {
+        ulong r = 0;
+        foreach (var v in data)
+            r ^= EliasDeltaEncode(v);
+        return r;
+    }
+
+    [Benchmark]
+    public ulong FibonacciEncode()
+    {
+        ulong r = 0;
+        foreach (var v in data)
+            r ^= Fibonacci.EncodeUInt(v);
+        return r;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static ulong EliasDeltaEncode(uint value)
+    {
+        value++;
+        var log2 = BitOperations.Log2(value);
+        var logLog2 = BitOperations.Log2((uint)log2 + 1);
+        ulong result = ((ulong)log2 + 1) ^ (1UL << logLog2);
+        result <<= (logLog2 + 1);
+        result |= (1U << logLog2);
+        // highest bit not cleared and bit ordering is different but it's ok for the test
+        result |= value << (2 * logLog2 + 1);
+        return result;
+    }
+}

FastFibCode.Benchmark/DecodeBenchmarks.cs

@@ -0,0 +1,42 @@
+using BenchmarkDotNet.Attributes;
+
+namespace FastFibCode.Benchmark;
+
+[InvocationCount(10)]
+public class DecodeBenchmarks
+{
+    [ParamsAllValues]
+    public Distribution Distribution { get; set; }
+
+    private ulong[] codes;
+
+    [GlobalSetup]
+    public void GlobalSetup()
+    {
+        DistributionData.Init();
+    }
+
+    [IterationSetup]
+    public void IterationSetup()
+    {
+        codes = DistributionData.GetCodes(Distribution);
+    }
+
+    [Benchmark(Baseline = true)]
+    public uint DecodeConventional()
+    {
+        uint r = 0;
+        foreach (var v in codes)
+            r ^= FibonacciSlow.DecodeAsUInt(v, true);
+        return r;
+    }
+
+    [Benchmark]
+    public uint DecodeFast()
+    {
+        uint r = 0;
+        foreach (var v in codes)
+            r ^= Fibonacci.DecodeAsUInt(v);
+        return r;
+    }
+}

FastFibCode.Benchmark/DecodeByteBenchmarks.cs

@@ -0,0 +1,35 @@
+using BenchmarkDotNet.Attributes;
+
+namespace FastFibCode.Benchmark;
+
+public class DecodeByteBenchmarks
+{
+    private static ushort[] codes = new ushort[1_000_000];
+
+    [GlobalSetup]
+    public void GlobalSetup()
+    {
+        for (int i = 0; i < codes.Length; i++)
+        {
+            codes[i] = Fibonacci.EncodeByte((byte)Random.Shared.Next(256));
+        }
+    }
+
+    [Benchmark(Baseline = true)]
+    public ushort DecodeAsUShort()
+    {
+        ushort r = 0;
+        foreach (var v in codes)
+            r ^= Fibonacci.DecodeAsUShort(v);
+        return r;
+    }
+
+    [Benchmark]
+    public byte DecodeAsByte()
+    {
+        byte r = 0;
+        foreach (var v in codes)
+            r ^= Fibonacci.DecodeAsByte(v);
+        return r;
+    }
+}

FastFibCode.Benchmark/DecodeUIntBenchmarks.cs

@@ -0,0 +1,35 @@
+using BenchmarkDotNet.Attributes;
+
+namespace FastFibCode.Benchmark;
+
+public class DecodeUIntBenchmarks
+{
+    private static ulong[] codes = new ulong[1_000_000];
+
+    [GlobalSetup]
+    public void GlobalSetup()
+    {
+        for (int i = 0; i < codes.Length; i++)
+        {
+            codes[i] = Fibonacci.EncodeUInt((uint)Random.Shared.Next());
+        }
+    }
+
+    [Benchmark(Baseline = true)]
+    public ulong DecodeAsULong()
+    {
+        ulong r = 0;
+        foreach (var v in codes)
+            r ^= Fibonacci.DecodeAsULong(v);
+        return r;
+    }
+
+    [Benchmark]
+    public uint DecodeAsUInt()
+    {
+        uint r = 0;
+        foreach (var v in codes)
+            r ^= Fibonacci.DecodeAsUInt(v);
+        return r;
+    }
+}

FastFibCode.Benchmark/DecodeUShortBenchmarks.cs

@@ -0,0 +1,35 @@
+using BenchmarkDotNet.Attributes;
+
+namespace FastFibCode.Benchmark;
+
+public class DecodeUShortBenchmarks
+{
+    private static uint[] codes = new uint[1_000_000];
+
+    [GlobalSetup]
+    public void GlobalSetup()
+    {
+        for (int i = 0; i < codes.Length; i++)
+        {
+            codes[i] = Fibonacci.EncodeUShort((ushort)Random.Shared.Next(ushort.MaxValue));
+        }
+    }
+
+    [Benchmark(Baseline = true)]
+    public uint DecodeAsUInt()
+    {
+        uint r = 0;
+        foreach (var v in codes)
+            r ^= Fibonacci.DecodeAsUInt(v);
+        return r;
+    }
+
+    [Benchmark]
+    public ushort DecodeAsUShort()
+    {
+        ushort r = 0;
+        foreach (var v in codes)
+            r ^= Fibonacci.DecodeAsUShort(v);
+        return r;
+    }
+}

FastFibCode.Benchmark/Distribution.cs

@@ -0,0 +1,18 @@
+namespace FastFibCode.Benchmark;
+
+public enum Distribution
+{
+    FoldedNormal_100,
+    FoldedNormal_1K,
+    FoldedNormal_10K,
+    FoldedNormal_100K,
+    FoldedNormal_1M,
+    FoldedNormal_10M,
+    Exponential_100,
+    Exponential_1K,
+    Exponential_10K,
+    Exponential_100K,
+    Exponential_1M,
+    Exponential_10M,
+    Uniform_5M
+}

FastFibCode.Benchmark/DistributionData.cs

@@ -0,0 +1,70 @@
+namespace FastFibCode.Benchmark;
+
+using static Distribution;
+
+public static class DistributionData
+{
+    private static readonly Dictionary<Distribution, uint[]> values = new Dictionary<Distribution, uint[]>();
+    private static readonly Dictionary<Distribution, ulong[]> codes = new Dictionary<Distribution, ulong[]>();
+
+    public static uint[] GetValues(Distribution distribution) => values[distribution];
+    public static ulong[] GetCodes(Distribution distribution) => codes[distribution];
+
+    public static void Init()
+    {
+        values.Clear();
+
+        values[FoldedNormal_100] = Create(() => FoldedNormalDistributionRandom(100));
+        values[FoldedNormal_1K] = Create(() => FoldedNormalDistributionRandom(1000));
+        values[FoldedNormal_10K] = Create(() => FoldedNormalDistributionRandom(10_000));
+        values[FoldedNormal_100K] = Create(() => FoldedNormalDistributionRandom(100_000));
+        values[FoldedNormal_1M] = Create(() => FoldedNormalDistributionRandom(1000_000));
+        values[FoldedNormal_10M] = Create(() => FoldedNormalDistributionRandom(10_000_000));
+
+        values[Exponential_100] = Create(() => ExponentialDistributionRandom(100));
+        values[Exponential_1K] = Create(() => ExponentialDistributionRandom(1000));
+        values[Exponential_10K] = Create(() => ExponentialDistributionRandom(10_000));
+        values[Exponential_100K] = Create(() => ExponentialDistributionRandom(100_000));
+        values[Exponential_1M] = Create(() => ExponentialDistributionRandom(1_000_000));
+        values[Exponential_10M] = Create(() => ExponentialDistributionRandom(10_000_000));
+
+        values[Uniform_5M] = Create(() => (uint)Random.Shared.Next(0, 5_000_000));
+
+        codes.Clear();
+        foreach (var p in values)
+        {
+            var cs = new ulong[p.Value.Length];
+            for (int i = 0; i < p.Value.Length; i++)
+                cs[i] = Fibonacci.EncodeUInt(p.Value[i]);
+            codes[p.Key] = cs;
+        }
+    }
+
+    private static uint[] Create(Func<uint> rnd)
+    {
+        uint[] data = new uint[1000_000];
+        for (int i = 0; i < data.Length; i++)
+            data[i] = rnd();
+        return data;
+    }
+
+    public static uint ExponentialDistributionRandom(uint sigma)
+        => (uint)Math.Round(-Math.Log(1 - Random.Shared.NextDouble()) * sigma);
+
+    public static uint FoldedNormalDistributionRandom(uint sigma)
+    {
+        // https://en.wikipedia.org/wiki/Folded_normal_distribution
+        double s = sigma;
+        var normalSigma = Math.Sqrt(s * s / (1 - 2 / Math.PI));
+        double u1, u2;
+        do
+        {
+            u1 = Random.Shared.NextDouble();
+        }
+        while (u1 == 0);
+        u2 = Random.Shared.NextDouble();
+
+        var mag = normalSigma * Math.Sqrt(-2.0 * Math.Log(u1));
+        return (uint)Math.Abs(mag * Math.Cos(2 * Math.PI * u2));
+    }
+}