Question

我正在尝试并行化C中的卷积函数。这是原始函数，它会卷积两个64位浮点数组：

void convolve(const Float64 *in1,
              UInt32 in1Len,
              const Float64 *in2,
              UInt32 in2Len,
              Float64 *results)
{
    UInt32 i, j;

    for (i = 0; i < in1Len; i++) {
        for (j = 0; j < in2Len; j++) {
            results[i+j] += in1[i] * in2[j];
        }
    }
}

为了允许并发（没有信号量），我创建了一个函数来计算results数组中特定位置的结果：

void convolveHelper(const Float64 *in1,
                    UInt32 in1Len,
                    const Float64 *in2,
                    UInt32 in2Len,
                    Float64 *result,
                    UInt32 outPosition)
{
    UInt32 i, j;

    for (i = 0; i < in1Len; i++) {
        if (i > outPosition)
            break;
        j = outPosition - i;
        if (j >= in2Len)
            continue;
        *result += in1[i] * in2[j];
    }
}

问题是，使用convolveHelper会使代码减慢约3.5倍（在单个线程上运行时）。

关于如何在保持线程安全的同时加快convolveHelper的任何想法？

Answer 1

时域中的卷积在傅立叶域中成为乘法。我建议你抓住一个快速FFT库（如FFTW）并使用它。你将从O（n ^ 2）到O（n log n）。

算法优化几乎总是优于微优化。

Answer 2

最明显的事情可能是预先计算循环的起始和结束索引，并删除i和j上的额外测试（及其相关的跳转）。这样：

for (i = 0; i < in1Len; i++) {
   if (i > outPosition)
     break;
   j = outPosition - i;
   if (j >= in2Len)
     continue;
   *result += in1[i] * in2[j];
}

可以改写为：

UInt32 start_i = (in2Len < outPosition) ? outPosition - in2Len + 1 : 0;
UInt32 end_i = (in1Len < outPosition) ? in1Len : outPosition + 1;

for (i = start_i; i < end_i; i++) {
   j = outPosition - i;
   *result += in1[i] * in2[j];
}

这样，条件j >= in2Len永远不会成立，循环测试基本上是测试i < in1Len和i < outPosition的组合。

理论上你也可以摆脱j的赋值并将i++变成++i，但编译器可能已经为你做了那些优化。

Answer 3

您可以在循环之前计算if的正确最小值/最大值，而不是循环中的两个i语句。
您正在分别计算每个结果位置。相反，您可以将results数组拆分为块，并让每个线程计算一个块。块的计算看起来像convolve函数。

Answer 4

除非您的数组非常大，否则使用线程实际上不太可能有用，因为启动线程的开销将大于循环的开销。但是，让我们假设您的阵列很大，并且线程是一个净胜利。在这种情况下，我会做以下事情：

忘记当前的convolveHelper，这太复杂了，也无济于事。

将循环内部拆分为线程函数。即只是制作

for (j = 0; j < in2Len; j++) {
    results[i+j] += in1[i] * in2[j];
}

进入自己的函数，将i作为参数与其他所有内容一起使用。

让convolve的主体简单地启动线程。为了获得最大效率，请使用信号量来确保永远不会创建比核心更多的线程。

Answer 5

答案在于Simple Math＆amp;不是多线程（更新）

这就是为什么......

考虑 a b + a c

U可以将其优化为 a *（b + c）（一个   多重复杂化）

在你的情况下，内循环中有 in2Len 不必要的乘法。哪个可以消除。

因此，如下修改代码应该给我们reqd卷积：

（注意：以下代码返回循环卷积，必须展开才能获得线性卷积结果。

void convolve(const Float64 *in1,
              UInt32 in1Len,
              const Float64 *in2,
              UInt32 in2Len,
              Float64 *results)
{
    UInt32 i, j;

    for (i = 0; i < in1Len; i++) {

        for (j = 0; j < in2Len; j++) {
            results[i+j] += in2[j];
        }

        results[i] = results[i] * in1[i];

    }
}

这应该给U带来最大的性能跳跃。试一试，看看!!

古德纳克!!

CVS @ 2600Hertz

Answer 6

我终于想出了如何正确预先计算开始/结束索引（由 Tyler McHenry 和 interjay 提供的建议）：

if (in1Len > in2Len) {
    if (outPosition < in2Len - 1) {
        start = 0;
        end = outPosition + 1;
    } else if (outPosition >= in1Len) {
        start = 1 + outPosition - in2Len;
        end = in1Len;
    } else {
        start = 1 + outPosition - in2Len;
        end = outPosition + 1;
    }
} else {
    if (outPosition < in1Len - 1) {
        start = 0;
        end = outPosition + 1;
    } else if (outPosition >= in2Len) {
        start = 1 + outPosition - in2Len;
        end = in1Len;
    } else {
        start = 0;
        end = in1Len;
    }
}

for (i = start; i < end; i++) {
    *result = in1[i] * in2[outPosition - i];
}

不幸的是，预先计算索引会导致执行时间没有明显减少 :(

Answer 7

让convolve helper在更大的集上工作，使用短外循环计算多个结果。

并行化的关键是在线程之间的工作分配之间找到一个很好的平衡点。不要使用比CPU核心数更多的线程。

在所有线程之间均匀分割工作。有了这种问题，每个线程工作的复杂性应该是相同的。

如何加速此循环（在C中）？

7 个答案:

答案在于Simple Math＆amp;不是多线程（更新）