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

Question

我有一个手推矩阵算法，该算法找到方矩阵右下角的最大数量（因此，迭代时，某些部分被“跳过”了）-存储为密集矩阵。从vs2010更新到vs2017后，它似乎要慢得多-总体上降低了50％。经过一番调查，它位于找到绝对最大值的函数的内循环中。查看assembler输出，这似乎是由于在紧密循环中插入了一些额外的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
• 不要用未使用的值初始化

也许这足以消除多余的动作？