Question

我正在努力提高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");
    }

Answer 1

您的实施速度较慢，因为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;
}

Answer 2

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

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

BitConvert.Int32，这不应该更快吗？

2 个答案: