2

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

这是我实现自旋锁的方法：

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;
            }
        }
    }
}

以下是多线程版本。这个版本在每次执行时都会产生相似但不同的结果，这是由无效的锁引起的。

[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 位像素值。它产生了预期的结果。

任何帮助表示赞赏。

4

2 回答 2

3

您是这里XY 问题的受害者。

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

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

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

现在有趣的部分：

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

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

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

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

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

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

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

您真正需要的是一种计算大型二维数组中数据总和的方法。所以你真正要找的是一个好的归约算法。Internet上有一些，或者您可以根据需要编写自己的代码。

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

关于分歧的题外话

NVIDIA - GPU 技术大会 2010 幻灯片

Goddeke - 入门教程

Donovan - GPU 并行扫描

Barlas - 多核和 GPU 编程

于 2019-09-23T14:04:33.950 回答
0

正如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 页的学士论文中详细解释了为什么这样做。还有一个 GLSL 示例。

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

于 2019-10-25T09:10:39.717 回答