将字节数组转换为 int 的更快方法

Question

有没有比 < 更快的方法code>BitConverter.ToInt32 将字节数组转换为 int 值？

Answer 1

我实际上尝试了几种不同的方法将四个字节转换为 int：

1. BitConverter.ToInt32(new byte[] { w, x, y, z }, 0);
2. BitConverter.ToUInt32(new byte[] { w, x, y, z }, 0);
3. b = new byte[] { w, x, y, z };
BitConverter.ToInt32(b, 0);
4. b = new byte[] { 1, 2, 3, 4, 5, 6, 7, w, x, y, z };
BitConverter.ToInt32(b, 7);
5. w | (x << 8) | (y << 16) | (y << 16) | (z << 24);
6. b[0] | (b[1] << 8) | (b[2] << 16) | (b[2] << 16) | (b[3] << 24);

我在发布 (x86) 版本中运行了 10^9 次迭代，而不是在 2.5 GHz Core i7 笔记本电脑。以下是我的结果（请注意，不使用 BitConverter 的方法要快得多）：

test1: 00:00:15.5287282 67305985
test2: 00:00:15.1334457 67305985
test3: 00:00:08.0648586 67305985
test4: 00:00:11.2307059 67305985
test5: 00:00:02.0219417 67305985
test6: 00:00:01.6275684 67305985

您可以得出一些结论：

• test1 显示在我的笔记本电脑上很难使转换速度慢于 15ns，我不想说这对任何人来说都应该足够快。 （每秒需要调用它超过 60M 次吗？）
• test2 表明使用 uint 代替 int 可以节省少量时间。我不知道为什么，但我认为它小到足以成为实验误差。
• test3 显示创建新字节数组的开销 (7ns) 与调用该函数几乎一样多，但仍然比从旧数组创建新数组要快。
• test4 显示从 ToInt32 进行未对齐的数组访问会增加开销 (3ns)
• test5 显示从局部变量中提取 4 个字节并自行组合它们比调用 ToInt32 快几倍。
• test6 表明，从数组中提取 4 个字节实际上比从函数参数中提取要快一些！我怀疑这是由于 CPU 流水线或缓存效应造成的。

最快的 test6 的运行时间仅为空循环（未显示）的两倍。换句话说，执行每次转换所需的时间不到 1ns。祝你好运，任何有用的计算都比这更快！

这是我的测试程序：

using System;

namespace BitConverterTest
{
    class Program
    {
        const int iters = 1000000000;
        static void Main(string[] args)
        {
            test1(1, 2, 3, 4);
            test2(1, 2, 3, 4);
            test3(1, 2, 3, 4);
            test4(1, 2, 3, 4);
            test5(1, 2, 3, 4);
            test6(1, 2, 3, 4);
        }

        static void test1(byte w, byte x, byte y, byte z)
        {
            int res = 0;
            var timer = System.Diagnostics.Stopwatch.StartNew();
            for (int i = 0; i < iters; i++)
                res = BitConverter.ToInt32(new byte[] { w, x, y, z }, 0);
            Console.WriteLine("test1: " + timer.Elapsed + " " + res);
        }

        static void test2(byte w, byte x, byte y, byte z)
        {
            uint res = 0;
            var timer = System.Diagnostics.Stopwatch.StartNew();
            for (int i = 0; i < iters; i++)
                res = BitConverter.ToUInt32(new byte[] { w, x, y, z }, 0);
            Console.WriteLine("test2: " + timer.Elapsed + " " + res);
        }

        static void test3(byte w, byte x, byte y, byte z)
        {
            int res = 0;
            var timer = System.Diagnostics.Stopwatch.StartNew();
            var b = new byte[] { w, x, y, z };
            for (int i = 0; i < iters; i++)
                res = BitConverter.ToInt32(b, 0);
            Console.WriteLine("test3: " + timer.Elapsed + " " + res);
        }

        static void test4(byte w, byte x, byte y, byte z)
        {
            int res = 0;
            var timer = System.Diagnostics.Stopwatch.StartNew();
            var b = new byte[] { 1, 2, 3, 4, 5, 6, 7, w, x, y, z };
            for (int i = 0; i < iters; i++)
                res = BitConverter.ToInt32(b, 7);
            Console.WriteLine("test4: " + timer.Elapsed + " " + res);
        }

        static void test5(byte w, byte x, byte y, byte z)
        {
            int res = 0;
            var timer = System.Diagnostics.Stopwatch.StartNew();
            var b = new byte[] { w, x, y, z };
            for (int i = 0; i < iters; i++)
                res = w | (x << 8) | (y << 16) | (z << 24);
            Console.WriteLine("test5: " + timer.Elapsed + " " + res);
        }

        static void test6(byte w, byte x, byte y, byte z)
        {
            int res = 0;
            var timer = System.Diagnostics.Stopwatch.StartNew();
            var b = new byte[] { w, x, y, z };
            for (int i = 0; i < iters; i++)
                res = b[0] | (b[1] << 8) | (b[2] << 16) | (b[3] << 24);
            Console.WriteLine("test6: " + timer.Elapsed + " " + res);
        }
    }
}

Answer 2

如果我没记错的话，该实现使用不安全的代码（将 byte* 视为 int*），因此很难击败，但另一种选择是移位。

然而，从该领域的大量工作来看，这不太可能成为真正的瓶颈，因此是无关紧要的。通常，I/O 是主要问题。

然而，由于数组/堆分配，GetBytes(int) 更昂贵（大量）。

Answer 3

Gabe 的性能测试的后续内容：

更改：

• 消除测试1和2，因为内联数组创建对GC进行了这些测试（从Gen 0 GC性能计数器可以看出）。
• 消除测试 4（非对齐数组）以使事情变得更简单。
• 添加测试 7 和 8，分别通过 BitConverter 和位摆弄从大型数组 (256 MB) 进行转换。
• 将运行总计添加到测试中，以尝试避免常见的子表达式消除，这显然会导致 Gabe 的测试 5 和 6 中的低时间。

结果：

• 32 位选项：

  <前><代码>测试3：00：00：06.9230577
  测试5：00:00:03.8349386
  测试6：00:00:03.8238272
  测试7：00:00:07.3898489
  测试8：00:00:04.6807391

• 64 位选项：

  <前><代码>测试3：00：00：05.8794322
  测试5：00:00:00.4384600
  测试6：00:00:00.4069573
  测试7：00:00:06.2279365
  测试8：00:00:03.5472486

分析

1. 64 位上的 5 和 6 中仍然会消除常见的子表达式。
2. 对于这个 64 位来说是一个胜利。但不应遵循这样的微基准来选择优化应用程序的位置。
3. 将 256 MB 随机数据转换为整数时，看起来大约提高了 50%。由于测试执行了 16 次，不到 0.2 秒 — 在非常狭窄的应用程序子集之外不太可能产生真正的差异，然后您需要额外的维护成本来确保有人不会在应用程序生命周期内破坏代码。
4. 我想知道 BitConverter 的参数检查开销有多少？
5. 测试 6 仅比测试 5 快一点。显然，数组边界检查正在被消除。

守则

using System;

namespace BitConverterTest {
    class Program {
        const int iters = 1024*1024*1024;
        const int arrayLen = iters/4;
        static byte[] array = new byte[arrayLen];

        static void Main(string[] args) {
            //test1(1, 2, 3, 4);
            //test2(1, 2, 3, 4);
            test3(1, 2, 3, 4);
            //test4(1, 2, 3, 4);
            test5(1, 2, 3, 4);
            test6(1, 2, 3, 4);

            // Fill array with good PRNG data
            var rng = new System.Security.Cryptography.RNGCryptoServiceProvider();
            rng.GetBytes(array);

            test7();
            test8();
        }

        // BitConverter with aligned input
        static void test3(byte w, byte x, byte y, byte z) {
            int res = 0;
            var timer = System.Diagnostics.Stopwatch.StartNew();
            var b = new byte[] { w, x, y, z };
            for (int i = 0; i < iters; i++)
                res = BitConverter.ToInt32(b, 0);
            Console.WriteLine("test3: " + timer.Elapsed + " " + res);
        }

        // Inline bitfiddling with separate variables.
        static void test5(byte w, byte x, byte y, byte z) {
            long res = 0;
            var timer = System.Diagnostics.Stopwatch.StartNew();
            var b = new byte[] { w, x, y, z };
            for (int i = 0; i < iters; i++) {
                int a = w | (x << 8) | (y << 16) | (z << 24);
                res += a;
            }
            Console.WriteLine("test5: " + timer.Elapsed + " " + res);
        }

        // Inline bitfiddling with array elements.
        static void test6(byte w, byte x, byte y, byte z) {
            long res = 0;
            var timer = System.Diagnostics.Stopwatch.StartNew();
            var b = new byte[] { w, x, y, z };
            for (int i = 0; i < iters; i++) {
                int a = b[0] | (b[1] << 8) | (b[2] << 16) | (b[3] << 24);
                res += a;
            }
            Console.WriteLine("test6: " + timer.Elapsed + " " + res);
        }

        // BitConvert from large array...
        static void test7() {
            var its = iters/arrayLen * 4; // *4 to remove arrayLen/4 factor.
            var timer = System.Diagnostics.Stopwatch.StartNew();
            long res = 0;
            for (var outer = 0; outer < its; outer++) {
                for (var pos = 0; pos < arrayLen; pos += 4) {
                    var x = BitConverter.ToInt32(array, pos);
                    res += x;
                }
            }
            Console.WriteLine("test7: " + timer.Elapsed + " " + res);
        }

        // Bitfiddle from large array...
        static void test8() {
            var its = iters/arrayLen * 4;
            var timer = System.Diagnostics.Stopwatch.StartNew();
            long res = 0;
            for (var outer = 0; outer < its; outer++) {
                for (var pos = 0; pos < arrayLen; pos += 4) {
                    int x = array[pos] | (array[pos+1] << 8) | (array[pos+2] << 16) | (array[pos+3] << 24);
                    res += x;
                }
            }
            Console.WriteLine("test8: " + timer.Elapsed + " " + res);
        }
    }
}

Answer 4

基于对 BitConverter.ToInt32 实施的快速回顾 在 .NET Reflector 中我会说“不”。

它针对数组对齐并直接转换字节的情况进行优化，否则执行按位合并。

Answer 5

我总结了以上所有内容，添加了 Span 变体并使用了基准框架。

public class ByteArrayToIntBench
{
    private readonly byte[] _array = new byte[4 * 10_000];

    public ByteArrayToIntBench()
    {
        Random r = new Random();
        for (int i = 0; i < _array.Length; i++)
        {
            _array[i] = (byte)r.Next(byte.MinValue, byte.MaxValue);
        }
    }

    [Benchmark]
    public double Bitconverter()
    {
        double res = 0;
        for (int i = 0; i < _array.Length; i += 4)
        {
            res += BitConverter.ToInt32(_array, i);
        }
        return res;
    }

    [Benchmark]
    public unsafe double Unsafe()
    {
        double res = 0;
        for (int i = 0; i < _array.Length; i += 4)
        {
            fixed (byte* pData = &_array[i])
            {
                res += *(int*)pData;
            }
        }
        return res;
    }

    [Benchmark]
    public double Shift()
    {
        double res = 0;
        for (int i = 0; i < _array.Length; i += 4)
        {
            res += _array[i] | (_array[i + 1] << 8) | (_array[i + 2] << 16) | (_array[i + 3] << 24);
        }
        return res;
    }

    [Benchmark]
    public double Span()
    {
        double res = 0;
        for (int i = 0; i < _array.Length; i += 4)
        {
            res += MemoryMarshal.Cast<byte, int>(_array.AsSpan(i, 4))[0];
        }
        return res;
    }
}

Answer 6

我也曾摆弄过类似的问题。

就我而言，当数据存储为双精度 byte[] 或仅在 double 之间时，如何转换为单精度 float > 表示和 byte[] 表示等。如果想要在大量数据上获得最佳性能，最好不要经过太多 API 层，并嵌入尽可能多的信息可以尽可能地融入到算法中，而不会使它变得太脆弱或难以理解。

因此，为了进一步跟进 Richard 的 测试，我在下面添加了另一个测试 (test9)，其中这是我在自己的工作中采用的方式，并在他的分析部分回答了他的第 4 点：

使用不安全的内存指针访问来实现最高性能的结果。当然如果你使用c++，但不一定是c#。这类似于 BitConverter 在幕后所做的事情，但没有参数和安全检查（因为，当然，我们知道我们在做什么......；）

结果：

• 32 位选项：

  <前><代码>测试3：00：00：06.2373138
  测试5：00:00:03.1193338
  测试6：00:00:03.1609287
  测试7：00:00:07.7328020
  测试8：00:00:06.4192130
  测试9：00:00:03.9590307

• 64 位选项：

  <预><代码>测试3：00：00：06.2209098
  测试5：00:00:00.5563930
  测试6：00:00:01.5486780
  测试7：00:00:08.4858474
  测试8：00:00:05.4991740
  测试9：00:00:02.2928944

这里是相同的代码，包括新的 test9：

using System;

namespace BitConverterTest
{
    class Program
    {
        const int iters = 1024 * 1024 * 1024;
        const int arrayLen = iters / 4;
        static byte[] array = new byte[arrayLen];

        static void Main(string[] args)
        {
            //test1(1, 2, 3, 4);
            //test2(1, 2, 3, 4);
            test3(1, 2, 3, 4);
            //test4(1, 2, 3, 4);
            test5(1, 2, 3, 4);
            test6(1, 2, 3, 4);

            // Fill array with good PRNG data
            var rng = new System.Security.Cryptography.RNGCryptoServiceProvider();
            rng.GetBytes(array);

            test7();
            test8();
            test9();
        }

        // BitConverter with aligned input
        static void test3(byte w, byte x, byte y, byte z)
        {
            int res = 0;
            var timer = System.Diagnostics.Stopwatch.StartNew();
            var b = new byte[] { w, x, y, z };
            for (int i = 0; i < iters; i++)
                res = BitConverter.ToInt32(b, 0);
            Console.WriteLine("test3: " + timer.Elapsed + " " + res);
        }

        // Inline bitfiddling with separate variables.
        static void test5(byte w, byte x, byte y, byte z)
        {
            long res = 0;
            var timer = System.Diagnostics.Stopwatch.StartNew();
            var b = new byte[] { w, x, y, z };
            for (int i = 0; i < iters; i++)
            {
                int a = w | (x << 8) | (y << 16) | (z << 24);
                res += a;
            }
            Console.WriteLine("test5: " + timer.Elapsed + " " + res);
        }

        // Inline bitfiddling with array elements.
        static void test6(byte w, byte x, byte y, byte z)
        {
            long res = 0;
            var timer = System.Diagnostics.Stopwatch.StartNew();
            var b = new byte[] { w, x, y, z };
            for (int i = 0; i < iters; i++)
            {
                int a = b[0] | (b[1] << 8) | (b[2] << 16) | (b[3] << 24);
                res += a;
            }
            Console.WriteLine("test6: " + timer.Elapsed + " " + res);
        }

        // BitConvert from large array...
        static void test7()
        {
            var its = iters / arrayLen * 4; // *4 to remove arrayLen/4 factor.
            var timer = System.Diagnostics.Stopwatch.StartNew();
            long res = 0;
            for (var outer = 0; outer < its; outer++)
            {
                for (var pos = 0; pos < arrayLen; pos += 4)
                {
                    var x = BitConverter.ToInt32(array, pos);
                    res += x;
                }
            }
            Console.WriteLine("test7: " + timer.Elapsed + " " + res);
        }

        // Bitfiddle from large array...
        static void test8()
        {
            var its = iters / arrayLen * 4;
            var timer = System.Diagnostics.Stopwatch.StartNew();
            long res = 0;
            for (var outer = 0; outer < its; outer++)
            {
                for (var pos = 0; pos < arrayLen; pos += 4)
                {
                    int x = array[pos] | (array[pos + 1] << 8) | (array[pos + 2] << 16) | (array[pos + 3] << 24);
                    res += x;
                }
            }
            Console.WriteLine("test8: " + timer.Elapsed + " " + res);
        }

        // unsafe memory operations from large array...
        // (essentialy internals of BitConverter without param checks, etc)
        static unsafe void test9()
        {
            var its = iters / arrayLen * 4;
            var timer = System.Diagnostics.Stopwatch.StartNew();
            long res = 0;
            int value = 0;
            for (var outer = 0; outer < its; outer++)
            {
                for (var pos = 0; pos < arrayLen; pos += 4)
                {
                    fixed (byte* numPtr = &array[pos])
                    {
                        value = *(int*)numPtr;
                    }
                    int x = *(int*)&value;
                    res += x;
                }
            }
            Console.WriteLine("test9: " + timer.Elapsed + " " + res);
        }

    }
}