directx - 在 HLSL DirectCompute 着色器中实现自旋锁

Question

我尝试在计算着色器中实现自旋锁。但是我的实现似乎没有锁定任何东西。

下面是我如何实现自旋锁:

void LockAcquire()
{
    uint Value = 1;

    [allow_uav_condition]
    while (Value) {
        InterlockedCompareExchange(DataOutBuffer[0].Lock, 0, 1, Value);
    };
}

void LockRelease()
{
    uint Value;
    InterlockedExchange(DataOutBuffer[0].Lock, 0, Value);
}

背景:我需要一个自旋锁，因为我必须计算大型二维数组中的数据总和。总和是双倍的。使用单线程和双循环计算总和会产生正确的结果。使用多线程计算总和会产生错误的结果，即使在引入自旋锁以避免计算总和时发生冲突也是如此。

我不能使用 InterLockedAdd，因为总和不适合 32 位整数，而且我使用的是着色器模型 5(编译器 47)。

这是单线程版本，产生了正确的结果:

[numthreads(1, 1, 1)]
void CSGrayAutoComputeSumSqr(
    uint3 Gid  : SV_GroupID,
    uint3 DTid : SV_DispatchThreadID, // Coordinates in RawImage window
    uint3 GTid : SV_GroupThreadID,
    uint  GI   : SV_GroupIndex)
{
    if ((DTid.x == 0) && (DTid.y == 0)) {
        uint2 XY;
        int   Mean = (int)round(DataOutBuffer[0].GrayAutoResultMean);
        for (XY.x = 0; XY.x < (uint)RawImageSize.x; XY.x++) {
            for (XY.y = 0; XY.y < (uint)RawImageSize.y; XY.y++) {
                int  Value  = GetPixel16BitGrayFromRawImage(RawImage, rawImageSize, XY);
                uint UValue = (Mean - Value) * (Mean - Value);
                DataOutBuffer[0].GrayAutoResultSumSqr += UValue;
            }
        }
    }
}

以下是多线程版本。此版本在每次执行时产生相似但不同的结果，IMO 是由不起作用的锁引起的。

[numthreads(1, 1, 1)]
void CSGrayAutoComputeSumSqr(
    uint3 Gid  : SV_GroupID,
    uint3 DTid : SV_DispatchThreadID, // Coordinates in RawImage window
    uint3 GTid : SV_GroupThreadID,
    uint  GI   : SV_GroupIndex)
{
    int  Value  = GetPixel16BitGrayFromRawImage(RawImage, RawImageSize, DTid.xy);
    int  Mean   = (int)round(DataOutBuffer[0].GrayAutoResultMean);
    uint UValue = (Mean - Value) * (Mean - Value);
    LockAcquire();
    DataOutBuffer[0].GrayAutoResultSumSqr += UValue;
    LockRelease();
}

使用的数据:

cbuffer TImageParams : register(b0)
{
    int2   RawImageSize;       // Actual image size in RawImage
}

struct TDataOutBuffer
{
    uint   Lock;                             // Use for SpinLock
    double GrayAutoResultMean;
    double GrayAutoResultSumSqr;
};

ByteAddressBuffer                  RawImage       : register(t0);
RWStructuredBuffer<TDataOutBuffer> DataOutBuffer  : register(u4);

发送代码:

FImmediateContext->CSSetShader(FComputeShaderGrayAutoComputeSumSqr, NULL, 0);
FImmediateContext->Dispatch(FImageParams.RawImageSize.X, FImageParams.RawImageSize.Y, 1);

GetPixel16BitGrayFromRawImage 函数访问 RawImage 字节地址缓冲区，从灰度图像中获取 16 位像素值。它产生了预期的结果。

感谢任何帮助。

Answer 1

您是 XY Problem 的受害者在这里。

让我们从 Y 问题开始。你的自旋锁没有锁定。要了解自旋锁为何不起作用，您需要检查 GPU 如何处理您正在创建的情况。您发出一个由一个或多个线程组组成的经线，每个线程组由许多线程组成。只要执行是并行的，warp 的执行就会很快，这意味着所有进行 warp 的线程(如果您愿意，可以使用 wavefront)必须在 相同的时间执行相同的指令时间。每次插入条件(如算法中的 while 循环)时，您的一些线程必须采用一条路线，而另一些则必须采用其他路线。这称为线程的发散。问题是您不能并行执行不同的指令。

在这种情况下，GPU 可以采用以下两种路线之一:

1. 动态分支 这意味着波前(经线)采用两条路线之一，并停用应该采用另一条路线的线程。然后，它会回滚以拾取它们所在的休眠线程。
2. 扁平分支，这意味着所有线程都执行两个分支，然后每个线程丢弃不需要的结果并保留正确的结果。

现在是有趣的部分:

没有强制转换规则说明 GPU 应该如何处理分支。

您无法预测 GPU 是否会使用一种方法，并且在动态分支的情况下，无法提前知道 GPU 是否会休眠直线路线，其他路线，分支用更少的线程或更多的线程。没有办法提前知道，不同的 GPU 可能会(并且会)以不同的方式执行代码。同一个 GPU 甚至可能会因不同的驱动程序版本而改变其执行方式。

对于自旋锁，您的 GPU(及其驱动程序和您当前使用的编译器版本)很可能会采用平面分支策略。这意味着两个分支都由 warp 的所有线程执行，因此基本上根本没有锁。

如果您更改代码(或在循环之前添加 [branch] 属性)，您可以强制执行动态分支流程。但这不能解决您的问题。在自旋锁的特殊情况下，您要求 GPU 做的是关闭除一个线程外的所有线程。而这并不是 GPU 想要做的。 GPU 将尝试做相反的事情，并关闭唯一以不同方式评估条件的线程。这确实会减少分歧并提高性能……但在您的情况下，它会关闭唯一不在无限循环中的线程。因此，您可能会在无限循环中锁定线程的完整波前，因为唯一可能解锁循环的……正在休眠。您的自旋锁实际上变成了死锁。

现在，在您的特定机器上，该程序甚至可能运行良好。但是您完全零保证该程序可以在其他机器上运行，甚至可以使用不同的驱动程序版本。你更新了驱动程序和繁荣，你的程序突然遇到 GPU 超时并崩溃。

关于 GPU 中自旋锁的最佳建议是……不要使用它们。曾经。

现在让我们回到你的Y问题。

您真正需要的是一种方法来计算大型二维数组中的数据总和。所以您真正需要的是一个好的缩减算法。互联网上有一些，或者您可以自己编写代码，具体取决于您的需要。

如果您需要，我将添加几个链接以帮助您入门。

A Digression on Divergence

NVIDIA - GPU Technology Conference 2010 Slides

Goddeke - Introductory tutorial

Donovan - GPU Parallel Scan

Barlas - Multicore and GPU programming