升级后内环性能下降的原因是什么？

Question

我有一个手动矩阵算法,它找到方阵的右下方的最大数量(因此在迭代时,某些部分被'跳过') - 存储为密集矩阵.在从vs2010到vs2017的更新之后,似乎要慢得多 - 总体上放缓了50%.经过一些调查,这被定位到函数的内部循环中找到绝对最大值.查看汇编器输出,这似乎是由于在紧密循环中插入了一些额外的mov指令.以不同方式重新循环似乎可以解决或部分解决问题. 相比之下,gcc似乎没有这个"问题".

简化示例(fabs并非总是需要重现):

#include <cmath>
#include <iostream>

int f_slow(double *A, size_t from, size_t w)
{
    double biga_absval = *A;
    size_t ir = 0,ic=0;
    for ( size_t j = 0; j < w; j++ ) {
      size_t n = j*w;
      for ( ; n < j*w+w; n++ ) {
        if ( fabs(A[n]) <= biga_absval ) {
          biga_absval = fabs( A[n] );
          ir   = j;
          ic   = n;
        }
        n++;
      }
    }

    std::cout << ir <<ic;
    return 0;
}

int f_fast(double *A, size_t from, size_t w)
{
    double* biga = A;
    double biga_absval = *biga;

    double* n_begin = A + from;
    double* n_end = A + w;
    for (double* A_n = n_begin; A_n < n_end; ++A_n) {
      if (fabs(*A_n) > biga_absval) {
        biga_absval = fabs(*A_n);
        biga = A_n;
      }
    }

    std::cout << biga;
    return 0;
}

int f_faster(double *A, size_t from, size_t w)
{
    double biga_absval = *A;
    size_t ir = 0,ic=0;
    for ( size_t j = 0; j < w; j++ ) {
      size_t n = j;
      for ( ; n < j*w+w; n++ ) {
        if ( fabs(A[n]) > biga_absval ) {
          biga_absval = fabs( A[n] );
          ir   = j;
          ic   = n - j*w;
        }
        n++;
      }
    }

    std::cout << ir <<ic;
    return 0;
}

请注意:创建的示例仅用于查看输出(并且索引等不是必要的):

https://godbolt.org/z/q9rWwi

所以我的问题是:这只是一个(已知？)优化器错误(？)还是有一些逻辑背后的情况似乎是一个明显的优化错过？

使用最新的稳定vs2017 15.9.5

更新:我看到的额外的mov是在跳转代码之前 - 在编译器资源管理器中找到最简单的方法是右键单击if然后"滚动到".

Answer 1

好吧，我不知道为什么 VC 在你的情况下会变得更糟，但我想提供一些如何确保某些操作安全的提示。

void f_faster( const double* A, const std::size_t w ) {
    double      biga_absval = A[ 0 ];
    std::size_t ir, ic_n;
    for ( std::size_t j = 0; j < w; ++j ) {
        const auto N = j * w + w;
        for ( std::size_t n = j; n < N; n += 2 ) {
            if ( const auto new_big_a = std::fabs( A[ n ] ); new_big_a > biga_absval ) {
                biga_absval = new_big_a;
                ir          = j;
                ic_n        = n;
            }
        }
    }

    std::cout << ir << ( ic_n - ir * w );
}

• 内循环不计算ic，只存储n以备后用
• 使用const来帮助优化器
• 不要评估 std::fabs 两次
• 后增量创建一个您不需要的副本（可能已优化掉）
• 将循环的上限存储在外部，否则可能会重新评估（可能会被优化掉）
• 只需将 n 加 2，而不是将 2 加 1
• 不要使用未使用的值进行初始化

也许这已经足以摆脱额外的 mov 了？