5

我的问题是在比较调试与发布时我的代码返回不同的结果。我检查了两种模式都使用 /fp:precise，所以这应该不是问题。我对此的主要问题是完整的图像分析（它是一个图像理解项目）是完全确定的，其中绝对没有随机性。

另一个问题是我的发布版本实际上总是返回相同的结果（图像为 23.014），而调试返回一些介于 22 和 23 之间的随机值，这是不应该的。我已经检查过它是否可能与线程相关，但算法中唯一的多线程部分在调试和发布时返回完全相同的结果。

这里还可能发生什么？

Update1：​​我现在发现负责此行为的代码：

float PatternMatcher::GetSADFloatRel(float* sample, float* compared, int sampleX, int compX, int offX)
{
    if (sampleX != compX)
    {
        return 50000.0f;
    }
    float result = 0;

    float* pTemp1 = sample;
    float* pTemp2 = compared + offX;

    float w1 = 0.0f;
    float w2 = 0.0f;
    float w3 = 0.0f;

    for(int j = 0; j < sampleX; j ++)
    {
        w1 += pTemp1[j] * pTemp1[j];
        w2 += pTemp1[j] * pTemp2[j];
        w3 += pTemp2[j] * pTemp2[j];
    }               
    float a = w2 / w3;
    result = w3 * a * a - 2 * w2 * a + w1;
    return result / sampleX;
}

更新 2： 这不能用 32 位代码重现。虽然调试和发布代码对于 32 位总是会产生相同的值，但它仍然与 64 位发布版本不同，并且 64 位调试仍然返回一些完全随机的值。

Update3： 好的，我发现它肯定是由 OpenMP 引起的。当我禁用它时，它工作正常。（Debug 和 Release 都使用相同的代码，并且都激活了 OpenMP）。

以下是给我带来麻烦的代码：

#pragma omp parallel for shared(last, bestHit, cVal, rad, veneOffset)
for(int r = 0; r < 53; ++r)
{
    for(int k = 0; k < 3; ++k)
    {
        for(int c = 0; c < 30; ++c)
        {
            for(int o = -1; o <= 1; ++o)
            {
                /*
                r: 2.0f - 15.0f, in 53 steps, representing the radius of blood vessel
                c: 0-29, in steps of 1, representing the absorption value (collagene)
                iO: 0-2, depending on current radius. Signifies a subpixel offset (-1/3, 0, 1/3)
                o: since we are not sure we hit the middle, move -1 to 1 pixels along the samples
                */

                int offset = r * 3 * 61 * 30 + k * 30 * 61 + c * 61 + o + (61 - (4*w+1))/2;

                if(offset < 0 || offset == fSamples.size())
                {
                    continue;
                }
                last = GetSADFloatRel(adapted, &fSamples.at(offset), 4*w+1, 4*w+1, 0);
                if(bestHit > last)
                {
                    bestHit = last;
                    rad = (r+8)*0.25f;
                    cVal = c * 2;
                    veneOffset =(-0.5f + (1.0f / 3.0f) * k + (1.0f / 3.0f) / 2.0f);
                    if(fabs(veneOffset) < 0.001)
                        veneOffset = 0.0f;
                }
                last = GetSADFloatRel(input, &fSamples.at(offset), w * 4 + 1, w * 4 + 1, 0);
                if(bestHit > last)
                {
                    bestHit = last;
                    rad = (r+8)*0.25f;
                    cVal = c * 2;
                    veneOffset = (-0.5f + (1.0f / 3.0f) * k + (1.0f / 3.0f) / 2.0f);
                    if(fabs(veneOffset) < 0.001)
                        veneOffset = 0.0f;
                }
            }
        }
    }
}

注意：在 Release 模式和 OpenMP 激活的情况下，我得到与停用 OpenMP 相同的结果。Debug 模式和 OpenMP 激活得到不同的结果，OpenMP deactivated 得到与 Release 相同的结果。

4

5 回答 5

12

至少有两种可能：

  1. 打开优化可能会导致编译器重新排序操作。与在调试模式下执行的顺序相比，这可能会在浮点计算中引入微小的差异，其中不会发生操作重新排序。这可能会解释调试和发布之间的数值差异，但不考虑调试模式下从一次运行到下一次运行的数值差异。
  2. 您的代码中存在与内存相关的错误，例如读取/写入超出数组的边界、使用未初始化的变量、使用未分配的指针等。尝试通过内存检查器运行它，例如出色的 Valgrind，以识别此类问题。与内存相关的错误可能会导致非确定性行为。

如果您在 Windows 上，则Valgrind不可用（遗憾），但您可以在此处查找替代列表。

于 2012-08-14T14:18:24.270 回答
6

为了详细说明我的评论，这很可能是您问题的根源：

#pragma omp parallel for shared(last, bestHit, cVal, rad, veneOffset)
{
    ...
    last = GetSADFloatRel(adapted, &fSamples.at(offset), 4*w+1, 4*w+1, 0);
    if(bestHit > last)
    {

last仅在再次读取之前分配给它，因此lastprivate如果您确实需要并行区域之外的最后一次迭代的值，它是一个很好的变量候选者。否则就成功了private。

访问bestHit、cVal、rad和veneOffset应由临界区同步：

#pragma omp critical
if (bestHit > last)
{
    bestHit = last;
    rad = (r+8)*0.25f;
    cVal = c * 2;
    veneOffset =(-0.5f + (1.0f / 3.0f) * k + (1.0f / 3.0f) / 2.0f);
    if(fabs(veneOffset) < 0.001)
        veneOffset = 0.0f;
}

请注意，默认情况下，除了parallel for循环的计数器和在并行区域内定义的那些变量之外，所有变量都是共享的，即shared除非您也应用该子句，否则您案例中的子句不会执行任何操作default(none)。

您应该注意的另一件事是，在 32 位模式下，Visual Studio 使用 x87 FPU 数学，而在 64 位模式下，它默认使用 SSE 数学。x87 FPU 使用 80 位浮点精度进行中间计算（即使float只涉及计算），而 SSE 单元仅支持标准的 IEEE 单精度和双精度。将 OpenMP 或任何其他并行化技术引入 32 位 x87 FPU 代码意味着在某些点，中间值应转换回单精度，float如果执行足够多次，则存在轻微或显着差异（取决于算法）可以在串行代码和并行代码的结果之间观察到。

根据您的代码，我建议以下修改后的代码将为您提供良好的并行性能，因为每次迭代都没有同步：

#pragma omp parallel private(last)
{
    int rBest = 0, kBest = 0, cBest = 0;
    float myBestHit = bestHit;

    #pragma omp for
    for(int r = 0; r < 53; ++r)
    {
        for(int k = 0; k < 3; ++k)
        {
            for(int c = 0; c < 30; ++c)
            {
                for(int o = -1; o <= 1; ++o)
                {
                    /*
                    r: 2.0f - 15.0f, in 53 steps, representing the radius of blood vessel
                    c: 0-29, in steps of 1, representing the absorption value (collagene)
                    iO: 0-2, depending on current radius. Signifies a subpixel offset (-1/3, 0, 1/3)
                    o: since we are not sure we hit the middle, move -1 to 1 pixels along the samples
                    */

                    int offset = r * 3 * 61 * 30 + k * 30 * 61 + c * 61 + o + (61 - (4*w+1))/2;

                    if(offset < 0 || offset == fSamples.size())
                    {
                        continue;
                    }
                    last = GetSADFloatRel(adapted, &fSamples.at(offset), 4*w+1, 4*w+1, 0);
                    if(myBestHit > last)
                    {
                        myBestHit = last;
                        rBest = r;
                        cBest = c;
                        kBest = k;
                    }
                    last = GetSADFloatRel(input, &fSamples.at(offset), w * 4 + 1, w * 4 + 1, 0);
                    if(myBestHit > last)
                    {
                        myBestHit = last;
                        rBest = r;
                        cBest = c;
                        kBest = k;
                    }
                }
            }
        }
    }
    #pragma omp critical
    if (bestHit > myBestHit)
    {
        bestHit = myBestHit;
        rad = (rBest+8)*0.25f;
        cVal = cBest * 2;
        veneOffset =(-0.5f + (1.0f / 3.0f) * kBest + (1.0f / 3.0f) / 2.0f);
        if(fabs(veneOffset) < 0.001)
        veneOffset = 0.0f;
    }
}

它只存储在每个线程中给出最佳命中的参数值，然后在它计算的并行区域的末尾rad，cVal并veneOffset基于最佳值。现在只有一个临界区，它位于代码的末尾。你也可以绕过它，但你必须引入额外的数组。

于 2012-08-15T13:00:18.787 回答
4

需要仔细检查的一件事是所有变量都已初始化。很多时候未优化的代码（调试模式）会初始化内存。

于 2012-08-14T14:20:47.180 回答
2

我会说调试中的变量初始化而不是发布中的变量初始化。但是您的结果不会支持这一点（发布时的可靠结果）。

您的代码是否依赖于任何特定的偏移量或大小？调试构建会在一些分配周围放置保护字节。

它可能与浮点有关吗？

调试浮点堆栈不同于为提高效率而构建的版本。

看这里：http ://thetweaker.wordpress.com/2009/08/28/debugrelease-numerical-differences/

于 2012-08-14T14:26:35.187 回答
2

几乎任何未定义的行为都可以解释这一点：未初始化的变量、流氓指针、同一对象的多次修改而没有中间序列点等等。结果有时不可再现的事实在某种程度上为未初始化的变量提供了支持，但它指针问题或边界错误也可能发生。

请注意，优化可能会改变结果，尤其是在 Intel 上。优化可以改变哪些中间值溢出到内存，如果你没有仔细使用括号，甚至表达式中的评估顺序。（众所周知，在机器浮点中，(a + b) + c) != a + (b + c)。）结果仍然应该是确定性的：根据优化程度，您将获得不同的结果，但对于任何一组优化标志，您应该获得相同的结果。

于 2012-08-14T14:33:35.643 回答