虽然对于优化C代码有很多有效的指导方针,但是对于彻底地了解编译器和你工作的机器依然无法取代,通常,加快程序的速度也会加大代码量。这些增加的代码也会影响一个程序的复杂度和可读性,这是不可接受的,比如你在一些小型的设备上编程,例如:移动设备、PDA……,这些有着严格的内存限制,于是,在优化的座右铭是:写代码在内存和速度都应该优化。
在我们知道使用的数不可能是负数的时候,应该使用unsigned int取代int,一些处理器处理整数算数运算的时候unsigned int比int快,于是,在一个紧致的循环里面定义一个整型变量,最好这样写代码:
1
|
register
unsigned
int
variable_name;
|
然而,我们不能保证编译器会注意到那个register关键字,也有可能,对某种处理器来说,有没有unsigned是一样的。这两个关键字并不是可以在所有的编译器中应用。记住,整形数运算要比浮点数运算快得多,因为处理器可以直接进行整型数运算,浮点数运算需要依赖于外部的浮点数处理器或者浮点数数学库。我们处理小数的时候要精确点些(比如我们在做一个简单的统计程序时),要限制结果不能超过100,要尽可能晚的把它转化成浮点数。
在标准的处理器中,根据分子和分母的不同,一个32位的除法需要20-140个时钟周期来执行完成,等于一个固定的时间加上每个位被除的时间。
Time (分子/ 分母) = C0 + C1* log2 (分子/分母)
= C0 + C1 * (log2 (分子) – log2 (分母)).
现在的ARM处理器需要消耗20+4.3N个时钟周期,这是一个非常费时的操作,要尽可能的避免。在有些情况下,除法表达式可以用乘法表达是来重写。比方说,(a/b)>c可以写成a>(c*b),条件是我们已经知道b为非负数而且b*c不会超过整型数的取值范围。如果我们能够确定其中的一个操作数为unsigned,那么使用无符号除法将会更好,因为它要比有符号除法快得多。
在一些情况下,除法运算和取余运算都需要用到,在这种情况下,编译器会将除法运算和取余运算合并,因为除法运算总是同时返回商和余数。如果两个运算都要用到,我们可以将他们写到一起。
1
2
3
4
5
6
7
|
typedef
unsigned
int
uint;
uint div32u (uint a) {
return
a / 32;
}
int
div32s (
int
a) {
return
a / 32;
}
|
这两种除法都会避免调用除法函数,另外,无符号的除法要比有符号的除法使用更少的指令。有符号的除法要耗费更多的时间,因为这种除法是使最终结果趋向于零的,而移位则是趋向于负无穷。
我们一般使用取余运算进行取模,不过,有时候使用 if 语句来重写也是可行的。考虑下面的两个例子:
1
2
3
4
5
6
7
8
9
10
|
uint modulo_func1 (uint count)
{
return
(++count % 60);
}
uint modulo_func2 (uint count)
{
if
(++count >= 60)
count = 0;
return
(count);
}
|
第二个例子要比第一个更可取,因为由它产生的代码会更快,注意:这只是在count取值范围在0 – 59之间的时候才行。
但是我们可以使用如下的代码(笔者补充)实现等价的功能:
1
2
3
4
5
6
|
uint modulo_func3 (uint count)
{
if
(++count >= 60)
count %= 60;
return
(count);
}
|
假设你要依据某个变量的值,设置另一个变量的取值为特定的字符,你可能会这样做:
1
2
3
4
5
6
7
8
|
switch
(queue) {
case
0 : letter =
'W'
;
break
;
case
1 : letter =
'S'
;
break
;
case
2 : letter =
'U'
;
break
;
}
|
或者这样:
1
2
3
4
5
6
|
if
(queue == 0)
letter =
'W'
;
else
if
( queue == 1 )
letter =
'S'
;
else
letter =
'U'
;
|
有一个简洁且快速的方式是简单的将变量的取值做成一个字符串索引,例如:
1
2
|
static
char
*classes =
"WSU"
;
letter = classes[queue];
|
全局变量不会被分配在寄存器上,修改全局变量需要通过指针或者调用函数的方式间接进行。所以编译器不会将全局变量存储在寄存器中,那样会带来额外的、不必要的负担和存储空间。所以在比较关键的循环中,我们要不使用全局变量。
如果一个函数要频繁的使用全局变量,我们可以使用局部变量,作为全局变量的拷贝,这样就可以使用寄存器了。条件是本函数调用的任何子函数不使用这些全局变量。
举个例子:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
int
f(
void
);
int
g(
void
);
int
errs;
void
test1(
void
)
{
errs += f();
errs += g();
}
void
test2(
void
)
{
int
localerrs = errs;
localerrs += f();
localerrs += g();
errs = localerrs;
}
|
可以看到test1()中每次加法都需要读取和存储全局变量errs,而在test2()中,localerrs分配在寄存器上,只需要一条指令。
考虑下面的例子:
1
2
3
4
5
6
|
void
func1(
int
*data )
{
int
i;
for
(i = 0; i < 10; i++)
anyfunc(*data, i);
}
|
即使*data从来没有变化,编译器却不知道anyfunc()没有修改它,于是程序每次用到它的时候,都要把它从内存中读出来,可能它只是某些变量的别名,这些变量在程序的其他部分被修改。如果能够确定它不会被改变,我们可以这样写:
1
2
3
4
5
6
7
8
|
void
func1(
int
*data )
{
int
i;
int
localdata;
localdata = *data;
for
(i=0; i<10; i++)
anyfunc(localdata, i);
}
|
这样会给编译器优化工作更多的选择余地。
寄存器的数量在每个处理器当中都是固定的,所以在程序的某个特定的位置,可以保存在寄存器中的变量的数量是有限制的。有些编译器支持“生命周期分割”(live-range splitting),也就是说在函数的不同部分,变量可以被分配到不同的寄存器或者内存中。变量的生存范围被定义成:起点是对该变量的一次空间分配,终点是在下次空间分配之前的最后一次使用之间。在这个范围内,变量的值是合法的,是活的。在生存范围之外,变量不再被使用,是死的,它的寄存器可以供其他变量使用,这样,编译器就可以安排更多的变量到寄存器当中。
可分配到寄存器的变量需要的寄存器数量等于经过生命范围重叠的变量的数目,如果这个数目超过可用的寄存器的数量,有些变量就必须被暂时的存储到内存中。这种处理叫做“泄漏(spilling)”。
编译器优先释放最不频繁使用的变量,将释放的代价降到最低。可以通过以下方式避免变量的“释放”:
C编译器支持基本的变量类型:char、short、int、long(signed、unsigned)、float、double。为变量定义最恰当的类型,非常重要,因为这样可以减少代码和数据的长度,可以非常显著的提高效率。
如果可能,局部变量要避免使用char和short。对于char和short类型,编译器在每次分配空间以后,都要将这种局部变量的尺寸减少到8位或16位。这对于符号变量来说称为符号扩展,对无符号变量称为无符号扩展。这种操作是通过将寄存器左移24或16位,然后再有符号(或无符号的)右移同样的位数来实现的,需要两条指令(无符号字节变量的无符号扩展需要一条指令)。
这些移位操作可以通过使用int和unsigned int的局部变量来避免。这对于那些首先将数据调到局部变量然后利用局部变量进行运算的情况尤其重要。即使数据以8位或16位的形式输入或输出,把他们当作32位来处理仍是有意义的。
我们来考虑下面的三个例子函数:
1
2
3
4
5
6
7
8
9
10
11
12
|
int
wordinc (
int
a)
{
return
a + 1;
}
short
shortinc (
short
a)
{
return
a + 1;
}
char
charinc (
char
a)
{
return
a + 1;
}
|
他们的运算结果是相同的,但是第一个代码片断要比其他片断运行的要快。
如果可能,我们应该使用结构体的引用作为参数,也就是结构体的指针,否则,整个结构体就会被压入堆栈,然后传递,这会降低速度。程序适用值传递可能需要几K字节,而一个简单的指针也可以达到同样的目的,只需要几个字节就可以了。
如果在函数内部不会改变结构体的内容,那么就应该将参数声明为const型的指针。举个例子:
1
2
3
4
|
void
print_data_of_a_structure (
const
Thestruct *data_pointer)
{
...
printf
contents of the structure...
}
|
这个例子代码告知编译器在函数内部不会改变外部结构体的内容,访问他们的时候,不需要重读。还可以确保编译器捕捉任何修改这个只读结构体的代码,给结构体以额外的保护。
指针链经常被用来访问结构体的信息,比如,下面的这段常见的代码:
1
2
3
4
5
6
7
8
|
typedef
struct
{
int
x, y, z; } Point3;
typedef
struct
{ Point3 *pos, *direction; } Object;
void
InitPos1(Object *p)
{
p->pos->x = 0;
p->pos->y = 0;
p->pos->z = 0;
}
|
代码中,处理器在每次赋值操作的时候都要重新装载p->pos,因为编译器不知道p->pos->x不是p->pos的别名。更好的办法是将p->pos缓存成一个局部变量,如下:
1
2
3
4
5
6
7
|
void
InitPos2(Object *p)
{
Point3 *pos = p->pos;
pos->x = 0;
pos->y = 0;
pos->z = 0;
}
|
另一个可能的方法是将Point3结构体包含在Object结构体中,完全避免指针的使用。
条件执行主要用在if语句中,同时也会用到由关系运算(<,==,>等)或bool运算(&&, !等)组成的复杂的表达式。尽可能的保持if和else语句的简单是有好处的,这样才能很好的条件化。关系表达式应该被分成包含相似条件的若干块。
下面的例子演示了编译器如何使用条件执行:
1
2
3
4
5
6
|
int
g(
int
a,
int
b,
int
c,
int
d)
{
if
(a > 0 && b > 0 && c < 0 && d < 0)
//分组化的条件被捆绑在一起
return
a + b + c + d;
return
-1;
}
|
条件被分组,便以其能够条件化他们。
有一种常见的boolean表达式被用来检查是否一个变量取值在某个特定的范围内,比方说,检查一个点是否在一个窗口内。
1
2
3
4
|
bool
PointInRectangelArea (Point p, Rectangle *r)
{
return
(p.x >= r->xmin && p.x < r->xmax && p.y >= r->ymin && p.y < r->ymax);
}
|
这里还有一个更快的方法:把(x >= min && x < max) 转换成 (unsigned)(x-min) < (max-min). 尤其是min为0时,更为有效。下面是优化后的代码:
1
2
3
4
|
bool
PointInRectangelArea (Point p, Rectangle *r)
{
return
((unsigned) (p.x - r->xmin) < r->xmax && (unsigned) (p.y - r->ymin) < r->ymax);
}
|
在比较(CMP)指令后,相应的处理器标志位就会被设置。这些标志位也可以被其他的指令设置,诸如MOV, ADD, AND, MUL, 也就是基本的数学和逻辑运算指令(数据处理指令)。假如一条数据处理指令要设置这些标志位,那么N和Z标志位的设置方法跟把数字和零比较的设置方法是一样的。N标志位表示结果是不是负数,Z标志位表示结果是不是零。
在C语言中,处理器中的N和Z标志位对应的有符号数的关系运算符是x < 0, x >= 0, x == 0, x != 0,无符号数对应的是x == 0, x != 0 (or x > 0)。
C语言中,每用到一个关系运算符,编译器就会产生一个比较指令。如果关系运算符是上面的其中一个,在数据处理指令紧跟比较指令的情况下,编译器就会将比较指令优化掉。比如:
1
2
3
4
5
6
7
|
int
aFunction(
int
x,
int
y)
{
if
(x + y < 0)
return
1;
else
return
0;
}
|
这样做,会在关键循环中节省比较指令,使代码长度减少,效率增加。C语言中没有借位(carry)标志位和溢出(overflow)标志位的概念,所以如果不使用内嵌汇编语言,要访问C和V标志位是不可能的。尽管如此,编译器支持借位标志位(无符号数溢出),比方说:
1
2
3
4
5
6
7
8
|
int
sum(
int
x,
int
y)
{
int
res;
res = x + y;
if
((unsigned) res < (unsigned) x)
// carry set? //
res++;
return
res;
}
|
在类似与这样的 if(a>10 && b=4) 语句中, 确保AND表达式的第一部分最有可能为false, 结果第二部分极有可能不被执行.
用switch() 代替if…else…,在条件选择比较多的情况下,可以用if…else…else…,像这样:
1
2
3
4
5
6
|
if
( val == 1)
dostuff1();
else
if
(val == 2)
dostuff2();
else
if
(val == 3)
dostuff3();
|
使用switch可以更快:
1
2
3
4
5
6
|
switch
( val )
{
case
1: dostuff1();
break
;
case
2: dostuff2();
break
;
case
3: dostuff3();
break
;
}
|
在if语句中,即使是最后一个条件成立,也要先判断所有前面的条件是否成立。Switch语句能够去除这些额外的工作。如果你不得不使用if…else,那就把最可能的成立的条件放在前面。
把判断条件做成二进制的风格,比如,不要使用下面的列表:
1
2
3
4
5
6
7
8
9
10
|
if
(a == 1) {
}
else
if
(a == 2) {
}
else
if
(a == 3) {
}
else
if
(a == 4) {
}
else
if
(a == 5) {
}
else
if
(a == 6) {
}
else
if
(a == 7) {
}
else
if
(a == 8) {
}
}
|
而采用:
1
2
3
4
5
6
7
8
9
10
11
12
13
|
if
(a <= 4) {
if
(a == 1) {
}
else
if
(a == 2) {
}
else
if
(a == 3) {
}
else
if
(a == 4) {
}
}
else
{
if
(a == 5) {
}
else
if
(a == 6) {
}
else
if
(a == 7) {
}
else
if
(a == 8) {
}
}
|
甚至:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
|
if
(a <= 4) {
if
(a <= 2) {
if
(a == 1) {
/* a is 1 */
}
else
{
/* a must be 2 */
}
}
else
{
if
(a == 3) {
/* a is 3 */
}
else
{
/* a must be 4 */
}
}
}
else
{
if
(a <= 6) {
if
(a == 5) {
/* a is 5 */
}
else
{
/* a must be 6 */
}
}
else
{
if
(a == 7) {
/* a is 7 */
}
else
{
/* a must be 8 */
}
}
}
|
慢速、低效:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
c = getch();
switch
(c){
case
'A'
: {
do
something;
break
;
}
case
'H'
: {
do
something;
break
;
}
case
'Z'
: {
do
something;
break
;
}
}
|
快速、高效:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
c = getch();
switch
(c) {
case
0: {
do
something;
break
;
}
case
1: {
do
something;
break
;
}
case
2: {
do
something;
break
;
}
}
|
以上是两个case语句之间的比较
switch语句通常用于以下情况:
如果case表示是密集的,在使用switch语句的前两种情况中,可以使用效率更高的查找表。比如下面的两个实现汇编代码转换成字符串的例程:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
|
char
* Condition_String1(
int
condition) {
switch
(condition) {
case
0:
return
"EQ"
;
case
1:
return
"NE"
;
case
2:
return
"CS"
;
case
3:
return
"CC"
;
case
4:
return
"MI"
;
case
5:
return
"PL"
;
case
6:
return
"VS"
;
case
7:
return
"VC"
;
case
8:
return
"HI"
;
case
9:
return
"LS"
;
case
10:
return
"GE"
;
case
11:
return
"LT"
;
case
12:
return
"GT"
;
case
13:
return
"LE"
;
case
14:
return
""
;
default
:
return
0;
}
}
char
* Condition_String2(
int
condition) {
if
((unsigned) condition >= 15)
return
0;
return
"EQNECSCCMIPLVSVCHILSGELTGTLE"
+
3 * condition;
}
|
第一个例程需要240个字节,第二个只需要72个。
如果不加留意地编写循环终止条件,就可能会给程序带来明显的负担。我们应该尽量使用“倒数到零”的循环,使用简单的循环终止条件。循环终止条件相对简单,程序在执行的时候也会消耗相对少的时间。拿下面两个计算n!的例子来说,第一个例子使用递增循环,第二个使用递减循环。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
int
fact1_func (
int
n)
{
int
i, fact = 1;
for
(i = 1; i <= n; i++)
fact *= i;
return
(fact);
}
int
fact2_func(
int
n)
{
int
i, fact = 1;
for
(i = n; i != 0; i--)
fact *= i;
return
(fact);
}
|
结果是,第二个例子要比第一个快得多。
这是一个简单而有效的概念,通常情况下,我们习惯把for循环写成这样:
1
|
for
( i = 0; i < 10; i++){ ... }
|
i 值依次为:0,1,2,3,4,5,6,7,8,9
在不在乎循环计数器顺序的情况下,我们可以这样:
1
|
for
( i = 10; i--; ) { ... }
|
i 值依次为: 9,8,7,6,5,4,3,2,1,0,而且循环要更快
这种方法是可行的,因为它是用更快的i–作为测试条件的,也就是说“i是否为非零数,如果是减一,然后继续”。相对于原先的代码,处理器不得不“把i减去10,结果是否为非零数,如果是,增加i,然后继续”,在紧密循环(tight loop)中,这会产生显著的区别。
这种语法看起来有一点陌生,却完全合法。循环中的第三条语句是可选的(无限循环可以写成这样for(;;)),下面的写法也可以取得同样的效果:
1
|
for
(i = 10; i; i--){}
|
或者:
1
|
for
(i = 10; i != 0; i--){}
|
我们唯一要小心的地方是要记住循环需要停止在0(如果循环是从50-80,这样做就不行了),而且循环的计数器为倒计数方式。
另外,我们还可以把计数器分配到寄存器上,可以产生更为有效的代码。这种将循环计数器初始化成循环次数,然后递减到零的方法,同样适用于while和do语句。
在可以使用一个循环的场合,决不要使用两个。但是如果你要在循环中进行大量的工作,超过处理器的指令缓冲区,在这种情况下,使用两个分开的循环可能会更快,因为有可能这两个循环都被完整的保存在指令缓冲区里了。
1
2
3
4
5
6
7
8
9
10
11
12
|
//原先的代码
for
(i = 0; i < 100; i++){
stuff();
}
for
(i = 0; i < 100; i++){
morestuff();
}
//更好的做法
for
(i = 0; i < 100; i++){
stuff();
morestuff();
}
|
调用函数的时候,在性能上就会付出一定的代价。不光要改变程序指针,还要将那些正在使用的变量压入堆栈,分配新的变量空间。为了提高程序的效率,在程序的函数结构上,有很多工作可以做。保证程序的可读性的同时,还要尽量控制程序的大小。
如果一个函数在一个循环中被频繁调用,就可以考虑将这个循环放在函数的里面,这样可以免去重复调用函数的负担,比如:
1
2
3
4
5
6
7
8
|
for
(i = 0 ; i < 100 ; i++)
{
func(t,i);
}
void
func(
int
w, d)
{
lots of stuff.
}
|
可以写成:
1
2
3
4
5
6
7
|
func(t);
void
func(w)
{
for
(i = 0; i < 100; i++) {
//lots of stuff.
}
}
|
为了提高效率,可以将小的循环解开,不过这样会增加代码的尺寸。循环被拆开后,会降低循环计数器更新的次数,减少所执行的循环的分支数目。如果循环只重复几次,那它完全可以被拆解开,这样,由循环所带来的额外开销就会消失。
比如:
1
2
3
4
5
6
7
|
for
(i = 0; i < 3; i++){
something(i);
}
//更高效的方式:
something(0);
something(1);
something(2);
|
因为在每次的循环中,i 的值都会增加,然后检查是否有效。编译器经常会把这种简单的循环解开,前提是这些循环的次数是固定的。对于这样的循环:
1
|
for
(i = 0; i < limit; i++) { ... }
|
就不可能被拆解,因为我们不知道它循环的次数到底是多少。不过,将这种类型的循环拆解开并不是不可能的。
与简单循环相比,下面的代码的长度要长很多,然而具有高得多的效率。选择8作为分块大小,只是用来演示,任何合适的长度都是可行的。例子中,循环的成立条件每八次才被检验一次,而不是每次都要检验。如果需要处理的数组的大小是确定的,我们就可以使用数组的大小作为分块的大小(或者是能够整除数组长度的数值)。不过,分块的大小跟系统的缓存大小有关。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
|
#include<stdio.H>
#define BLOCKSIZE (8)
int
main(
void
)
{
int
i = 0;
int
limit = 33;
/* could be anything */
|