Unsafe.As 从字节数组到 ulong 数组

Question

我目前正在考虑移植我的 metro hash implementon 以使用 C#7 功能，因为有几个部分可能会从 ref locals 中受益以提高性能。 哈希在 ulong[4] 数组上进行计算，但结果是 16 byte 数组。目前我正在将ulong 数组复制到结果byte 缓冲区，但这需要一些时间。 所以我想知道System.Runtime.CompilerServices.Unsafe 在这里使用是否安全：

var result = new byte[16];
ulong[] state = Unsafe.As<byte[], ulong[]>(ref result);
ref var firstState = ref state[0];
ref var secondState = ref state[1];
ulong thirdState = 0;
ulong fourthState = 0;

上面的代码 sn-p 意味着我将结果缓冲区也用于部分状态计算，而不仅仅是用于最终输出。

我的单元测试是成功的，根据 benchmarkdotnet 跳过块复制将导致 20% 性能提升，这足以让我确定使用它是否正确。

Answer 1

在当前的 .NET 术语中，这非常适合 Span<T>：

Span<byte> result = new byte[16];
Span<ulong> state = MemoryMarshal.Cast<byte, ulong>(result);

这会强制执行长度等，同时具有良好的 JIT 行为并且不需要unsafe。您甚至可以 stackalloc 原始缓冲区（从 C# 7.2 开始）：

Span<byte> result = stackalloc byte[16];
Span<ulong> state = MemoryMarshal.Cast<byte, ulong>(result);

注意Span<T> 的长度变化是正确的；如果您想使用 SIMD 进行硬件加速，也可以将其转换为 Span<Vector<T>>。

Answer 2

你正在做的似乎很好，只是要小心，因为没有什么可以阻止你这样做：

byte[] x = new byte[16];
long[] y = Unsafe.As<byte[], long[]>(ref x);

Console.WriteLine(y.Length); // still 16

for (int i = 0; i < y.Length; i++)
    Console.WriteLine(y[i]); // reads random memory from your program, could cause crash

Answer 3

C# 支持“固定缓冲区”，我们可以这样做：

    public unsafe struct Bytes
    {
        public fixed byte bytes[16];
    }

然后

    public unsafe static Bytes Convert (long[] longs)
    {
        fixed (long * longs_ptr = longs)
              return *((Bytes*)(longs_ptr));
    }

试试看。 （C# 中原始类型的一维数组始终存储为连续的内存块，这就是为什么获取（托管）数组的地址是可以的）。

您甚至可以返回指针以获得更快的速度：

    public unsafe static Bytes * Convert (long[] longs)
    {
        fixed (long * longs_ptr = longs)
        return ((Bytes*)(longs_ptr));
    }

并根据需要操作/访问字节。

        var s = Convert(longs);
        var b = s->bytes[0];