parallel_for 中互斥锁的多线程替代方案

Question

我是 C++ 的新手，因此如果这是一个愚蠢的问题请原谅，但我没有在 Internet 上找到我正在寻找的很好的例子。

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

我的代码：

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，而它可以由其他线程同时写入。通常，除非 both 双方都受到原子语义或锁和内存栅栏的保护，否则您不得读取同时写入的值。一个原因是变量访问很可能包含多个内存访问，具体取决于硬件支持的类型。

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

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

parallel_for 中互斥锁的多线程替代方案

Multithreading alternative to mutex in parallel_for

c++

performance

multithreading

mutex

ppl