以前学过一阵子汇编,后来又忘记了不少,最近翻起来,又发现在C++层其实有很多可以编程习惯,可以根据汇编原理进行优化。


多使用float.

为了让编译器产生更好的3DNow!或SSE指令代码,我们可以必须确定浮点型变量和表达式是float型的,为避免float自动转换为double,我们声明时需要强调,并在后面加以f后缀。


适时使用无符号整形

  • int转换float/double类型时,建议使用有符号整形,因为X86构架中,提供了从int转换为float/double类型的指令,而没有提供unsigned int转换为浮点型的指令,我们看下编译器反汇编后的汇编代码。
double x;          mov [temp + 4], 0
unsigned int x;    mov eax, i
x = i;             mov [temp], eax
               flid qword ptr [temp]
               fstp qword ptr [x]

这段代码不仅指令数多,而且因为指令配对失败造成的FLID指令会被延迟执行,代码运行较慢。 而使用无符号整形的话,会快的多,反汇编如下

double x;         flid qword ptr [i]
int i;            flid qword ptr [x]
x = i;

指令配对,代码运行较快

  • 对整形求商求余时,使用无符号整形会比较快,我们也以汇编代码查看分析
int i;               mov eax, i
i = i / 4;           cdq
                     and edx, 3
                     and edx, edx
                     sar eax, 2
                     mov i, eax

而当我们使用无符号整形时

unsigned int i;              shr i, 2
i = i / 4;
  • 同样,在循环计数,数组下标时,尽可能的使用无符号整形,会提高代码运行速度。

多使用for,少使用while

我们依旧是看反汇编代码。

while( 1 );                      mov eax, 1
                                 test eax, eax
                                 je temp+23h
                                 jmp temp+18h

而for的则是

for( ; ; );                      jmp temp=23h

多使用数组,少使用指针

我这条建议恐怕要受到广大C++程序员的责骂与非议,而实际上编译器是很难对指针进行优化的,因为默认的编译器会假设指针可以访问任何的内存地址。而我们使用操作符[]来访问数组的话,会让编译器减少产生不安全代码的问题


循环的优化

  • 人工拆分小循环 为了充分的利用CPU的指令缓存,我们可以把一些很小的循环手工拆开,虽然这样写出的代码会显得有些冗余“低水平”,而这样做的确可以提高性能。例如
  // 3D转化:把矢量V和4x4矩阵M相乘
  for (i = 0; i < 4; i ++)
  {
    r[i] = 0;
    for (j = 0; j < 4; j ++)
    {
      r[i] += M[j][i]*V[j];
    }
  }

我们可以将其拆分为

  // 3D转化:把矢量V和4x4矩阵M相乘
  r[0] = M[0][0]*V[0] + M[1][0]*V[1] + M[2][0]*V[2] + M[3][0]*V[3];
  r[1] = M[0][1]*V[0] + M[1][1]*V[1] + M[2][1]*V[2] + M[3][1]*V[3];
  r[2] = M[0][2]*V[0] + M[1][2]*V[1] + M[2][2]*V[2] + M[3][2]*V[3];
  r[3] = M[0][3]*V[0] + M[1][3]*V[1] + M[2][3]*V[2] + M[3][3]*v[3];
  • 小循环写外,大循环写里,这样可以避免断掉CPU的连续循环指令。例如
for( unsigned int i=0; i<=10; ++i )
{
     for( unsigned int j=0; j<=10000; ++j )
     {
      // TODO:
     }  
}

就比下面的好

for( unsigned int j=0; j<=10000; ++j )
{
     for( unsigned int j=0; j<=10; ++i )
     {
      // TODO:
     }  
}

同样的道理,循环与判断嵌套时,我们也可以将判断放外,循环放内比较好,避免判断打断循环指令。


避免使用无必要的读写依赖

当数据保存到内存时存在读写依赖,尽管AMD Athlon等CPU有加速读写依赖延迟的硬件,允许将保存的数据在写入前读取出来,但是,我们手工将读写保存去除的话,代码性能能有很大的提升。 我们的做法通常是牺牲一定的空间在寄存器中创建一个临时变量。


优化Switch

Switch可能使用多种算法进行优化,其中最普通的是跳转表和比较链。我推荐大家将最有可能的case放在第一位,此时比较链会得到一定性能的提高,另外,case尽量使用比较小的连续整数,因为此时编译器会将Switch转化为跳转表。


尽量多的使用常量const

因为C++标准规定,若一个const对象的地址不被获取,编译器可以不对它分配存储空间。


多使用内联函数和静态函数

当然,内联函数不是越多越好,它是以代码膨胀以代价的加速,根据需要吧。而static强制使用内部连接的函数可以进行代码的优化,不然编译器默认的会把函数定义为外部连接。


困了,今天就先分析到这里。