优化 C++ 代码以匹配参考运行时间

Question

我有优化一些 c++ 代码的任务，我不擅长编码，但我做了一些尝试，所以原来的是：

#include "stdafx.h"
#include "HistogramStretching.h"



void CHistogramStretching::HistogramStretching(BYTE** pImage, int nW, int nH)
{
    //find minimal value
    int nMin = pImage[0][0];
    for(int j = 0; j < nW; j++)
        for(int i = 0; i < nH; i++)
            if(pImage[i][j] < nMin)
                nMin = pImage[i][j];

    //find maximal value
    int nMax = pImage[0][0];
    for(int j = 0; j < nW; j++)
        for(int i = 0; i < nH; i++)
            if(pImage[i][j] > nMax)
                nMax = pImage[i][j];

    //stretches histogram
    for(int j = 0; j < nW; j++)
        for(int i = 0; i < nH; i++)
        {
            if(nMax != nMin)
            {
                float fScale = (nMax - nMin)/100.0;//calculates scale
                float fVal = (pImage[i][j] - nMin)/fScale;//scales pixel value
                int nVal = (int)(fVal + 0.5);//rounds floating point number to integer

                //checks BYTE range (must be 0-255)
                if(nVal < 0)
                    nVal = 0;
                if(nVal > 255)
                    nVal = 255;

                pImage[i][j] = nVal;
            }
            else
                pImage[i][j] = 0;//if all pixel values are the same, the image is changed to black
        }

}

我的版本是：

#include "stdafx.h"
#include "HistogramStretching.h"

void CHistogramStretching::HistogramStretching(BYTE** pImage, int nW, int nH)
{
    //find minimal value
    int nMin = pImage[0][0];
    int nMax = pImage[0][0];
    for (int j = 0; j < nW; j++) {
        for (int i = 0; i < nH; i++) {
            if (pImage[i][j] < nMin)
                nMin = pImage[i][j];
            if (pImage[i][j] > nMax)
                nMax = pImage[i][j];

        }
    }

    if (nMax != nMin) {
        float fScale = (nMax - nMin) / 100.0;//calculates scale
        fScale = 1 / fScale;
        //stretches histogram
        for (int j = 0; j < nW; j++)
            for (int i = 0; i < nH; i++)
            {


                float fVal = (pImage[i][j] - nMin) * fScale;//scales pixel value
                int nVal = (int)(fVal + 0.5);//rounds floating point number to integer

                //checks BYTE range (must be 0-255)
                if (nVal < 0)
                    nVal = 0;
                if (nVal > 255)
                    nVal = 255;

                pImage[i][j] = nVal;
            }
        //if all pixel values are the same, the image is changed to black

    }
    else {
        pImage[0][0] = 0;

    }
}

所以我将前两个循环合并为一个，但仍然是第一个 if 占用约 15% 的 CPU 时间，下一步是将 if 语句拉出循环并更改乘法除法，这里除法占用约 8% 的 CPU 时间和浮点数到 int 铸造需要 ~5% 但我认为我不能做太多铸造。 通过这种“更正”，我的代码仍然比参考代码慢 6-7 倍。 我在同一台机器上测试这两种代码。 你能指出我可以做得更好的东西吗？

Answer 1

我认为塔德曼给了你正确的答案。 代替

for (int j = 0; j < nW; j++) {
    for (int i = 0; i < nH; i++) {
        if (pImage[i][j] < nMin)
        ...
    }
}

和

for (int i = 0; i < nH; i++) {
    for (int j = 0; j < nW; j++) {
        if (pImage[i][j] < nMin)
        ...
    }
}

这样你的数据访问就变成了缓存/内存对齐，这应该会更快。

Answer 2

当以完全优化编译时，所有现代编译器都可以很好地对此进行矢量化（/O2 用于 MSVC，-O3 用于 gcc 和 clang）。

这个想法是给编译器一些帮助，以便它可以看到代码实际上可以被矢量化：

1. 让内部循环对单个指针而不是索引进行操作，并且除了指向的值之外不访问任何内容。

2. 执行缩放作为 integer 操作 - 不要忘记四舍五入:)

3. 尝试设置不需要额外范围检查的操作，例如检查BYTE是否小于 0。通过正确设置偏移量和比例，结果将保证落在所需范围内。

内部循环将展开，并将被矢量化以一次处理 4 个字节。 我尝试了最近的 gcc、clang 和 MSVC 版本，它们为此生成了相当快的代码。

您正在做一些“奇怪”的事情，因为您有目的地将结果缩放到 0-99 范围内。 因此你失去了数据的分辨率 - 你有一个完整的字节可以使用，那么为什么不将它缩放到 255？

但是，如果您想扩展到 100 个值，那很好。 注意 100(dec) = 0x64。 我们可以使outputSpan灵活——它适用于 <= 255 的任何值。

因此：

/* Code Part 1 */
#include <cstdint>

constexpr uint32_t outputSpan = 100;

static constexpr uint32_t scale_16(uint8_t min, uint8_t max)
{
    return (outputSpan * 0x10000) / (1+max-min);
}
// scale factor in 16.16 fixed point unsigned format
// empty histogram produces scale = outputSpan
static_assert(scale_16(10, 10) == outputSpan * 0x10000, "Scale calculation is wrong");

static constexpr uint8_t scale_pixel(uint8_t const pixel, uint8_t min, uint32_t const scale)
{
    uint32_t px  = (pixel - min) * scale;
    // result in 16.16 fixed point format
    return (px + 0x8080u) >> 16;
    // round to an integer value
}

我们使用定点数（而不是浮点数）。 刻度为 16.16 格式，因此 integer 部分为 16 位，小数部分为 16 位，例如 0x1234.5678。 值 1.0(dec) 将为 0x1.0000。

像素缩放只是将像素乘以比例，对其进行舍入，并返回截断后的 integer 部分。

四舍五入是“有趣的”。 您可能认为将 0.5(dec) = 0x0.8 添加到结果中以对其进行舍入就足够了。 事实并非如此。 该值需要比那个大一点，0x0.808 就可以了。 它对值进行预偏置，以便精确值周围的误差范围具有零均值。 在所有情况下，误差最多为 ±0.5 - 因此四舍五入为 integer 的结果不会失去准确性。

我们使用scale_16和scale_pixel函数来实现拉伸器：

/* Code Part 2 */
void stretchHistogram(uint8_t **pImage, int const nW, int const nH)
{
    uint8_t nMin = 255, nMax = 0;

    for (uint8_t **row = pImage, **rowEnd = pImage + nH; row != rowEnd; ++row)
        for (const uint8_t *p = *row, *pEnd = p + nW; p != pEnd; ++p)
        {
            auto const px = *p;
            if (px < nMin) nMin = px;
            if (px > nMax) nMax = px;
        }

    auto const scale = scale_16(nMin, nMax);

    for (uint8_t **row = pImage, **rowEnd = pImage + nH; row != rowEnd; ++row)
        for (uint8_t *p = *row, *pEnd = p + nW; p != pEnd; ++p)
            *p = scale_pixel(*p, nMin, scale);
}

这也会在没有 FPU 的架构上生成不错的代码，例如 FPU-less ARM 和 AVR。

我们也可以做一些人工检查。 假设min = 0x10 、 max = 0xEF和pixel = 0x32 。 让我们记住scale是 16.16 格式：

scale = 0x64.0000 / (1 + max - min)
      = 0x64.0000 / (1 + 0xEF - 0x10)
      = 0x64.0000 / (1 + 0xDF)
      = 0x64.0000 / 0xE0

长除法：

       0x  .7249
       0x64.0000 / 0xE0
       ---------
         64.0
       - 62.0
       ------
          2.00
       -  1.C0
       -------
           .400
       -   .380
       --------
           . 800
       -   . 7E0
       ---------
           .  20

所以，我们有scale = 0x0.7249 。 它小于一 (0x1.0)，也略小于 1/2 (0x0.8)，因为我们将 map 224 个值加到 100 个值上 - 略小于一半。

现在

px = (pixel - min) * scale 
   = (0x32 - 0x10) * 0x0.7249
   =  0x22 * 0x0.7249

长乘法：

   0x 0.7249
*  0x  .0022
------------
       .E492
+     E.492
------------
   0x F.2DB2

因此， px = 0xF.2DB2 ≈ 0xF 。 我们必须将其四舍五入为 integer：

return = (px + 0x0.8080u) >> 16
       = (0xF.2DB2 + 0x0.8080) >> 16
       =  0xF.AE32 >> 16
       ≈  0xF 

让我们检查十进制：

100 / (max-min+1) * (pixel-min) =
                                = 100 / (239 - 16 + 1) * (50 - 16)
                                = 100 / 224 * 34
                                = 100 * 34 / 224
                                = 3400 / 224
                                ≈ 15.17 
                                ≈ 15
                                ≈ 0xF

这是一个测试用例，可确保min 、 max和输入像素值的所有组合都没有舍入偏差，并且误差限制在 [-0.5, 0.5]。 只需将 append 添加到上面的代码，它应该编译并运行并生成以下 output：

-0.5 0.5 1

要缩放到outputSpan = 256个值（而不是 100 个），它会是 output：

-0.498039 0.498039 0.996078

/* Code Part 3 */

#include <cassert>
#include <cmath>
#include <iostream>

int main()
{
    double errMin = 0, errMax = 0;

    for (uint16_t min = 0; min <= 255; ++min)
        for (uint16_t max = min; max <= 255; ++max)
            for (uint16_t val = min; val <= max; ++val)
        {
            uint8_t const nMin = min, nMax = max;
            uint8_t const span = nMax - nMin;
            uint8_t const val_src = val;
            uint8_t p_val = val_src;
            uint8_t *const p = &p_val;
            assert(nMin <= nMax);
            assert(val >= nMin && val <= nMax);

            auto const scale = scale_16(nMin, nMax);
            *p = scale_pixel(*p, nMin, scale);

            auto pValTarget = (val_src - nMin) * 256.0/(1.0+span);
            auto error = pValTarget - *p;
            if (error < errMin) errMin = error;
            if (error > errMax) errMax = error;
        }

    std::cout << '\n' << errMin << ' ' << errMax << ' ' << errMax-errMin << std::endl;
    assert((errMax-errMin) <= 1.0); // constrain the error
    assert(std::abs(errMax+errMin) == 0.0); // constrain the error average
}