在 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 的线程（如果您愿意，可以使用波前），必须在 [=] 处执行 相同的指令 54=]同时。每次插入条件（如算法中的 while 循环）时，您的某些线程必须采用一条路线，而另一些则必须采用其他路线。这称为线程的分歧。问题是您不能并行执行不同的指令。

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

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

现在是有趣的部分：

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

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

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

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

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

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

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

您真正需要的是一种计算大型二维数组中数据总和的方法。所以你真正要找的是一个好的 reduction algorithm。网上有一些，也可以自己编码，看自己需要。

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

A Digression on Divergence

NVIDIA - GPU Technology Conference 2010 Slides

Goddeke - Introductory tutorial

Donovan - GPU Parallel Scan

Barlas - Multicore and GPU programming

Answer 2

正如 kefren 所提到的，你的自旋锁因为经线发散而不起作用。然而，有一种方法可以设计不会导致死锁的 gpu 自旋锁。我将这个自旋锁用于像素着色器，但它也应该在计算着色器中工作。

RWTexture2D<uint> mutex; // all values are 0 in the beginning

void doCriticalPart(int2 coord) {
   bool keepWaiting = true;
   while(keepWaiting) {
      uint originalValue;
      // try to set the mutex to 1
      InterlockedCompareExchange(mutex[coord], 0, 1, originalValue);
      if(originalValue == 0) { // nothing was locked (previous entry was 0)
         // do your stuff
         // unlock mutex again
         InterlockedExchange(mutex[coord], 0, originalValue);
         // exit loop
         keepWaiting = false;
      }
   }
}

在我的第 30 页的 Bachelor Thesis 中详细解释了为什么这有效。还有一个 GLSL 示例。

注意：如果你想在像素着色器中使用这个自旋锁，你必须在调用这个函数之前检查SV_SampleIndex == 0。像素着色器可能会产生一些帮助程序调用来确定纹理获取 mipmap 级别，这会导致原子操作出现未定义的行为。这可能会导致那些帮助程序调用的循环无限执行，从而导致死锁

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

Implementing a SpinLock in a HLSL DirectCompute shader

directx

hlsl

spinlock

directcompute