Visual C++优化异常：含alpha判断的代码运行反而更慢

问题背景 #

我编写了一段带Alpha通道蒙版的图像绘制代码，原本想通过跳过Alpha值为0的像素实现性能优化。但实际测试中，添加if (a)判断的代码反而比无判断版本慢30-40%（测试图像约40%像素Alpha为0，合成图像50%Alpha为0）；在独立测试代码里，注释掉该判断后代码速度提升约20%。测试环境为Intel i9、Windows 10、32位Release版本（已开启速度优化），生成的汇编代码无异常。请问这一现象的原因是什么？

原图像绘制代码 #

BYTE* pSrc, * pDest;
const int nBottom = min(rSrcRect.Height(), pDibDest->Height() - rDestRect.top);
const int nRight = min(rSrcRect.Width(), pDibDest->Width() - rDestRect.left);
for (int y = 0; y < nBottom; y++)
{
  pSrc = pDibSrc->GetPixel(rSrcRect.left, rSrcRect.top + y);
  pDest = pDibDest->GetPixel(rDestRect.left, rDestRect.top + y);
  for (int x = 0; x < nRight; x++)
  {
    int a = pSrc[x * nSrcAlign + 3];
// 下面这个"优化"实际上让代码变慢了
    if (a)
//
    {
      int _a = 255 - a;
      pDest[0 + x * nDestAlign] = ((int)pDest[0 + x * nDestAlign] * _a + (int)pSrc[0 + x * nSrcAlign] * a + 127) / 255;
      pDest[1 + x * nDestAlign] = ((int)pDest[1 + x * nDestAlign] * _a + (int)pSrc[1 + x * nSrcAlign] * a + 127) / 255;
      pDest[2 + x * nDestAlign] = ((int)pDest[2 + x * nDestAlign] * _a + (int)pSrc[2 + x * nSrcAlign] * a + 127) / 255;
    }
  }
}

独立测试代码 #

#include <stdio.h>
#include <windows.h>

void OptText(unsigned char *pA, unsigned char *pB, int startx, int w, int h, int linewa, int linewb)
{
  const int nSrcAlign = 4;
  const int nDestAlign = 3;
  unsigned char* pSrc, * pDest;
  for (int y = 0; y < h; y++)
  {
    pSrc = pA + startx * nSrcAlign + y * linewa;
    pDest = pB + y * linewb;
    for (int x = 0; x < w; x++)
    {
      int a = pSrc[x * nSrcAlign + 3];
      //if (a)
      {
        int _a = 255 - a;
        pDest[0 + x * nDestAlign] = ((int)pDest[0 + x * nDestAlign] * _a + (int)pSrc[0 + x * nSrcAlign] * a + 127) / 255;
        pDest[1 + x * nDestAlign] = ((int)pDest[1 + x * nDestAlign] * _a + (int)pSrc[1 + x * nSrcAlign] * a + 127) / 255;
        pDest[2 + x * nDestAlign] = ((int)pDest[2 + x * nDestAlign] * _a + (int)pSrc[2 + x * nSrcAlign] * a + 127) / 255;
      }
    }
  }
}

int main()
{
  int maxw = 2048;
  int maxh = 2048;
  int linewa = maxw * 4;
  int linewb = maxh * 3;
  unsigned char* pTestData1 = new unsigned char[maxw * maxh * 4];
  unsigned char* pTestData2 = new unsigned char[maxw * maxh * 3];
  srand(10000);
  for (int i = 0; i < maxw * maxh * 4; i++)
  {
    if (i % 4 == 3)
      pTestData1[i] = rand() % 2;
    else
      pTestData1[i] = rand() % 256;
  }
  for (int i = 0; i < maxw * maxh * 3; i++)
    pTestData2[i] = rand() % 256;

  int t1 = GetTickCount();
  
  for (int i = 0; i < 10000; i++)
  {
    int startx = rand() % (maxw / 2);
    unsigned char *pA = pTestData1 + rand() % (maxh / 2) * linewa;
    unsigned char* pB = pTestData2 + rand() % (maxh / 2) * linewb;
    int w = rand() % (maxw / 2);
    int h = rand() % (maxh / 2);
    OptText(pA, pB, startx, w, h, linewa, linewb);
  }

  int t2 = GetTickCount();
  printf("Run %d msec\n", t2 - t1);
}

原因分析 #

这种反直觉的现象核心原因是CPU分支预测失效和指令流水线停顿，具体拆解如下：

• 分支预测命中率暴跌：你的测试数据中Alpha值0和非0的比例接近50%，属于完全随机的分支场景。现代CPU的分支预测器擅长处理有规律的分支（比如连续大量相同结果），但面对50%概率的随机分支，预测准确率会跌到接近50%。每次预测失败，CPU都要清空流水线、回退到分支前的状态重新执行，这部分开销远大于跳过50%像素节省的计算量。
• 指令流水线连续性被破坏：没有if判断时，代码是完全线性的，CPU可以把指令拆分成微指令在流水线中连续执行，充分利用超标量CPU的并行处理能力。加入if后，流水线会被分支打断，即使预测成功也需要额外的分支指令处理，预测失败的代价更是成倍放大。
• 内存访问连贯性受损：随机跳过部分像素写入会破坏内存访问的连续性，而CPU缓存系统对连续读写的效率远高于随机访问，缓存命中率下降会进一步拖慢速度。
• 计算量对比失衡：你代码里的混合计算（乘法、加法、除法）都是简单的整数运算，CPU执行这些指令的速度极快。跳过50%计算省下来的时间，根本抵不上分支预测失败带来的额外开销。

另外，32位版本下CPU寄存器资源相对紧张，分支判断会占用更多寄存器保存分支状态，也会间接影响整体执行效率。

内容的提问来源于Stack Exchange，提问作者PiotrK