0

我正在尝试提高 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");
    }
4

2 回答 2

3

您的实现速度较慢，因为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;
}
于 2013-08-17T21:14:10.113 回答
2

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

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

于 2013-08-17T21:06:19.193 回答