代码之家  ›  专栏  ›  技术社区  ›  darune

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

  •  7
  • darune  · 技术社区  · 7 年前

    我有一个手动滚动矩阵算法,它可以找到一个正方形矩阵的右下正方形的最大数目(因此,当迭代时,某些部分被“跳过”)存储为密集矩阵。在来自的更新之后 这似乎要慢得多——总体上大约有50%的减速。经过一些调查,这被定位到一个函数的内环,寻找绝对最大值。看着 输出,这似乎是由于一些额外的 相比之下,似乎没有这个“问题”。

    简化示例( 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

    使用最新的稳定 15.9.5

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

    0 回复  |  直到 5 年前
        1
  •  1
  •   malik    5 年前

    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进行两次评估
    • 将循环的上限存储在外部,否则它可能会被重新计算(可能会被优化掉)
    • 不要使用未使用的值初始化