BitConvert.Int32，Shouldn´；这不会更快

本文关键字：#180 Int32 Shouldn BitConvert | 更新日期: 2023-09-27 18:28:06

我正在努力提高BitConvert的速度，或者更确切地说，是一种替代方法。

这是我认为应该更快的代码：

    bsize = ms.length
    int index = 0;
    byte[] target = new byte[intsize];
    target[index++] = (byte)bsize;
    target[index++] = (byte)(bsize >> 8);
    target[index++] = (byte)(bsize >> 16);
    target[index] = (byte)(bsize >> 24);

以及BitConvert代码：

BitConverter.GetBytes(bsize)

好吧，它并不快，从我的测试来看，它慢得多，慢了一倍多。

那么，为什么速度较慢呢？有没有办法提高速度？

编辑：

BitConvert = 5068 Ticks
OtherMethod above: 12847 Ticks

编辑2：我的基准代码：

private unsafe void ExecuteBenchmark(int samplingSize = 100000)
    {
        // run the Garbage collector
        GC.Collect();
        GC.WaitForPendingFinalizers();
        // log start
        Console.WriteLine("Benchmark started");
        // start timer
        var t = Stopwatch.StartNew();
                for (int i = 0; i < samplingSize; i++)
                {
                }
        }
        // stop timer
        t.Stop();
        // log ending
        Console.WriteLine("Execute1 time = " + t.ElapsedTicks + " ticks");
    }

BitConvert.Int32，Shouldn´；这不会更快

您的实现速度较慢，因为BitConverter使用了对指针进行操作的unsafe代码：

public unsafe static byte[] GetBytes(int value)
{
    byte[] array = new byte[4];
    fixed (byte* ptr = array)
    {
        *(int*)ptr = value;
    }
    return array;
}

返回int:

public unsafe static int ToInt32(byte[] value, int startIndex)
{
    if (value == null)
    {
        ThrowHelper.ThrowArgumentNullException(ExceptionArgument.value);
    }
    if ((ulong)startIndex >= (ulong)((long)value.Length))
    {
        ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.startIndex, ExceptionResource.ArgumentOutOfRange_Index);
    }
    if (startIndex > value.Length - 4)
    {
        ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_ArrayPlusOffTooSmall);
    }
    int result;
    if (startIndex % 4 == 0)
    {
        result = *(int*)(&value[startIndex]);
    }
    else
    {
        if (BitConverter.IsLittleEndian)
        {
            result = ((int)(*(&value[startIndex])) | (int)(&value[startIndex])[(IntPtr)1 / 1] << 8 | (int)(&value[startIndex])[(IntPtr)2 / 1] << 16 | (int)(&value[startIndex])[(IntPtr)3 / 1] << 24);
        }
        else
        {
            result = ((int)(*(&value[startIndex])) << 24 | (int)(&value[startIndex])[(IntPtr)1 / 1] << 16 | (int)(&value[startIndex])[(IntPtr)2 / 1] << 8 | (int)(&value[startIndex])[(IntPtr)3 / 1]);
        }
    }
    return result;
}

首先，测量这么少量代码的速度很容易出错。发布你的基准可能会给出更多答案。

但我的猜测是，在支持它的平台上（如x86），BitConverter可能会对target进行单边界检查和未对齐的写入，而不是3次移位、4次边界检查和4次写入。它可能最终完全内联，从而减轻所有调用开销。

相关文章：