如何并行对 Span<T> 进行操作？

Question

我想同时对Span<T> 进行操作，但这样的事情是不合法的：

void DoSomething(Span<int> buffer, int option1, int option2)
{
   ....... 
}

void ParallelDoSomething(Span<int> buffer)
{
    var size = buffer.Length;
    Parallel.Invoke(() => DoSomething(buffer, 0, size / 2),
        () => DoSomething(buffer, size/2, size)); //not legal
}

因为编译器抱怨：不能在匿名方法、lambda 表达式、查询表达式或本地函数中使用 ref、out 或 in 参数“缓冲区”

如何在以Span<T> 作为参数的并行方法中执行？

Answer 1

这里的问题是Span<T> 不能被允许进入堆 - 它仅在堆栈上有效 - 这意味着它不能被装箱，或用作class 上的字段（或struct，ref struct 除外）。这排除了捕获的变量和最常见的state 参数形式。

如果您有幸将输入更改为内存，则可以捕获 内存，并在 lambda 主体中获取跨度内部：

void ParallelDoSomething(Memory<int> memory)
{
    var size = memory.Length;
    Parallel.Invoke(
        () => DoSomething(memory.Span, 0, size / 2),
        () => DoSomething(memory.Span, size/2, size)
    );
}

如果你不能改变输入，你仍然可以这样做……通过作弊。您可以pin 现有跨度，创建一个覆盖该固定数据的内存，并使用 该 内存，就像它作为内存传入一样。这并不完全是微不足道的，因为您需要编写自己的基于指针的内存管理器实现，但是：它可以工作。这是来自 protobuf-net 的示例：https://github.com/protobuf-net/protobuf-net/blob/main/src/protobuf-net.Core/Meta/TypeModel.cs#L767-L789

或者更方便的是，固定 span 并直接捕获 指针，注意编译器通常不允许这样做（以防止指针稍后被委托使用），但是 既然我们知道时间语义，我们可以通过复制指针让它变得快乐：

unsafe void ParallelDoSomething(Span<int> span)
{
    var size = span.Length;
    fixed (int* ptr = span)
    {
        int* evil = ptr; // make the compiler happy
        Parallel.Invoke(
            () => DoSomething(new Span<int>(evil, size), 0, size / 2),
            () => DoSomething(new Span<int>(evil, size), size / 2, size)
        );
    }
}

或者如果我们想在输入点修复切片跨度：

unsafe void ParallelDoSomething(Span<int> span)
{
    var size = span.Length;
    fixed (int* ptr = span)
    {
        int* evil = ptr; // make the compiler happy
        Parallel.Invoke(
            () => DoSomething(new Span<int>(evil, size / 2));
            () => DoSomething(new Span<int>(evil + (size/2), size - (size/2));
        );
    }
}