多线程替代parallel_for中的互斥锁

Question

我对 C++ 还很陌生，因此如果这是一个愚蠢的问题，请原谅，但我没有在互联网上找到我正在寻找的好例子。

基本上，我使用 parallel_for 循环来查找 2D 数组中的最大值（以及介于两者之间的一堆其他操作）。首先我什至不知道这是否是最好的方法，但考虑到这个二维数组的长度，我认为拆分计算会更快。

我的代码：

vector<vector<double>> InterpU(1801, vector<double>(3601, 0));
Concurrency::parallel_for(0, 1801, [&](int i) {

    long k = 0; long l = 0;
    pair<long, long> Normalized;
    double InterpPointsU[4][4];
    double jRes;
    double iRes = i * 0.1;
    double RelativeY, RelativeX;
    int p, q;

    while (iRes >= (k + 1) * DeltaTheta) k++;
    RelativeX = iRes / DeltaTheta - k;
    for (long j = 0; j < 3600; j++)
    {
        jRes = j * 0.1;
        while (jRes >= (l + 1) * DeltaPhi) l++;
        RelativeY = jRes / DeltaPhi - l;
        p = 0;
        for (long m = k - 1; m < k + 3; m++)
        {
            q = 0;
            for (long n = l - 1; n < l + 3; n++)
            {
                Normalized = Normalize(m, n, PointsTheta, PointsPhi);
                InterpPointsU[p][q] = U[Normalized.first][Normalized.second];
                q++;
            }
            p++;
        }
        InterpU[i][j] = bicubicInterpolate(InterpPointsU, RelativeX, RelativeY);
        if (InterpU[i][j] > MaxU)
        {
            SharedDataLock.lock();
            MaxU = InterpU[i][j];
            SharedDataLock.unlock();
        }
    }
    InterpU[i][3600] = InterpU[i][0];
});

您可以在这里看到我使用了一个名为SharedDataLock 的mutex 来保护访问同一资源的多个线程。 MaxU 是一个变量，应该只包含 InterpU 向量的最大值。 该代码运行良好，但由于我遇到速度性能问题，我开始研究atomic 和其他一些东西。

有没有什么好的例子可以说明如何修改类似的代码以使其更快？

Answer 1

正如VTT所说，你可以简单地找到每个线程的局部最大值，然后将它们合并使用combinable：

Concurrency::combinable<double> CombinableMaxU;
Concurrency::parallel_for(0, 1801, [&](int i) {
    ...
        CombinableMaxU.local() = std::max(CombinableMaxU.local(), InterpU[i][j]);
}
MaxU = std::max(MaxU, CombinableMaxU.combine(std::max<double>));

请注意，您当前的代码实际上是错误（除非MaxU 是原子的），您在锁之外读取MaxU，而它可以被其他线程同时写入。通常，您不能读取同时写入的值，除非双方都受到原子语义或锁和内存栅栏的保护。一个原因是变量访问很可能由多个内存访问组成，具体取决于硬件如何支持该类型。

但在你的情况下，你甚至有一个经典的竞争条件：

MaxU == 1
  Thread a                 |   Thread b
InterpU[i][j] = 3          | InterpU[i][j] = 2
if (3 > MaxU)              |  if (2 > MaxU)
SharedDataLock.lock();     | SharedDataLock.lock();
(gets the lock)            | (waiting for lock)
MaxU = 3                   | ...
SharedDataLock.unlock();   | ...
...                        | (gets the lock)
                           | MaxU = 2
                           | SharedDataLock.unlock();
MaxU == 2

Locks are hard.

您也可以使用原子和compute the maximum on that。但是，我猜¹它在循环内仍然不能很好地执行²，而在循环外，你使用原子还是锁都没有关系。

^{1：有疑问时，不要猜测 - 测量！}

^{2：仅仅因为某些东西是原子的并且由硬件支持，并不意味着它与访问本地数据一样高效。首先，原子指令通常比它们的非原子指令成本更高，其次你必须处理非常糟糕的缓存效果，因为核心/缓存会争夺数据的所有权。虽然在许多情况下原子可能更优雅（恕我直言，不是这一次），但大多数情况下减少速度更快。}