无止境的内存优化——停不下的循环

小伙伴们是否是跟我同样，觉得以前的内存优化已经完成了？不，这才刚刚开始……让咱们一块儿进入这无休止的循环吧！

switch语句和查找表 / Switch statement vs. lookup tables

switch语句一般用于如下状况：

调用几个函数中的一个

设置一个变量或返回值

执行几个代码片段中的一个

若是case表示是密集的，在使用switch语句的前两种状况中，可使用效率更高的查找表。好比下面的两个实现汇编代码转换成字符串的例程：

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
          "EQ\0NE\0CS\0CC\0MI\0PL\0VS\0VC\0HI\0LS\0GE\0LT\0GT\0LE\0\0" +
           3 * condition;
}

第一个例程须要240个字节，第二个只须要72个。

循环终止 / Loop termination

若是不加留意地编写循环终止条件，就可能会给程序带来明显的负担。咱们应该尽可能使用“倒数到零”的循环，使用简单的循环终止条件。循环终止条件相对简单，程序在执行的时候也会消耗相对少的时间。拿下面两个计算n!的例子来讲，第一个例子使用递增循环，第二个使用递减循环。

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()循环 / Faster for() loops

这是一个简单而有效的概念，一般状况下，咱们习惯把for循环写成这样：

for( i = 0;  i < 10;  i++){ ... }

i 值依次为：0,1,2,3,4,5,6,7,8,9

在不在意循环计数器顺序的状况下，咱们能够这样：

for( i = 10;  i--; ) { ... }

i 值依次为: 9,8,7,6,5,4,3,2,1,0,并且循环要更快

这种方法是可行的，由于它是用更快的i--做为测试条件的，也就是说“i是否为非零数，若是是减一，而后继续”。相对于原先的代码，处理器不得不“把i减去10，结果是否为非零数，若是是，增长i，而后继续”，在紧密循环(tight loop)中，这会产生显著的区别。

这种语法看起来有一点陌生，却彻底合法。循环中的第三条语句是可选的（无限循环能够写成这样for(;;)）,下面的写法也能够取得一样的效果：

for(i = 10;  i;  i--){}

或者:

for(i = 10;  i != 0;  i--){}

咱们惟一要当心的地方是要记住循环须要中止在0（若是循环是从50-80，这样作就不行了），并且循环的计数器为倒计数方式。

另外，咱们还能够把计数器分配到寄存器上，能够产生更为有效的代码。这种将循环计数器初始化成循环次数，而后递减到零的方法，一样适用于while和do语句。

混合循环/ Loop jamming 在可使用一个循环的场合，决不要使用两个。可是若是你要在循环中进行大量的工做，超过处理器的指令缓冲区，在这种状况下，使用两个分开的循环可能会更快，由于有可能这两个循环都被完整的保存在指令缓冲区里了。

// 原先的代码
for(i = 0; i < 100; i++){
    stuff();
}
for(i = 0; i < 100; i++){
    morestuff();
}        
//更好的作法
for(i = 0; i < 100; i++){
    stuff();
    morestuff();
}

函数循环 / Function Looping

调用函数的时候，在性能上就会付出必定的代价。不光要改变程序指针，还要将那些正在使用的变量压入堆栈，分配新的变量空间。为了提升程序的效率，在程序的函数结构上，有不少工做能够作。保证程序的可读性的同时，还要尽可能控制程序的大小。

若是一个函数在一个循环中被频繁调用，就能够考虑将这个循环放在函数的里面，这样能够免去重复调用函数的负担，好比：

for(i = 0 ; i < 100 ; i++) 
{ 
    func(t,i); 
}
void func(int w, d) 
{ 
    lots of stuff. 
}

能够写成：

func(t);
void func(w) 
{ 
    for(i = 0; i < 100; i++) { 
        //lots of stuff. 
    } 
}

展开循环 / Loop unrolling

为了提升效率，能够将小的循环解开，不过这样会增长代码的尺寸。循环被拆开后，会下降循环计数器更新的次数，减小所执行的循环的分支数目。若是循环只重复几回，那它彻底能够被拆解开，这样，由循环所带来的额外开销就会消失。

好比:

for(i = 0; i < 3; i++){ 
    something(i);
}
//更高效的方式：
something(0);
something(1);
something(2);

由于在每次的循环中，i 的值都会增长，而后检查是否有效。编译器常常会把这种简单的循环解开，前提是这些循环的次数是固定的。对于这样的循环：

for(i = 0; i <  limit; i++) { ... }

就不可能被拆解，由于咱们不知道它循环的次数究竟是多少。不过，将这种类型的循环拆解开并非不可能的。

与简单循环相比，下面的代码的长度要长不少，然而具备高得多的效率。选择8做为分块大小，只是用来演示，任何合适的长度都是可行的。例子中，循环的成立条件每八次才被检验一次，而不是每次都要检验。若是须要处理的数组的大小是肯定的，咱们就可使用数组的大小做为分块的大小（或者是可以整除数组长度的数值）。不过，分块的大小跟系统的缓存大小有关。

#include<stdio.H> 
#define BLOCKSIZE (8) 
int main(void)
{ 
    int i = 0; 
    int limit = 33;  /* could be anything */ 
    int blocklimit;

    /* The limit may not be divisible by BLOCKSIZE, 
      go as near as we can first, then tidy up.
     */ 
    blocklimit = (limit / BLOCKSIZE) * BLOCKSIZE;

    /* unroll the loop in blocks of 8 */ 
    while(i < blocklimit) { 
        printf("process(%d)\n", i); 
        printf("process(%d)\n", i+1); 
        printf("process(%d)\n", i+2); 
        printf("process(%d)\n", i+3); 
        printf("process(%d)\n", i+4); 
        printf("process(%d)\n", i+5); 
        printf("process(%d)\n", i+6); 
        printf("process(%d)\n", i+7); 
        /* update the counter */ 
        i += 8; 
    } 
    /* 
     * There may be some left to do.
     * This could be done as a simple for() loop, 
     * but a switch is faster (and more interesting) 
     */ 
    if( i < limit ) 
    { 
        /* Jump into the case at the place that will allow
         * us to finish off the appropriate number of items. 
         */ 
        switch( limit - i ) 
        { 
            case 7 : printf("process(%d)\n", i); i++; 
            case 6 : printf("process(%d)\n", i); i++; 
            case 5 : printf("process(%d)\n", i); i++; 
            case 4 : printf("process(%d)\n", i); i++; 
            case 3 : printf("process(%d)\n", i); i++; 
            case 2 : printf("process(%d)\n", i); i++; 
            case 1 : printf("process(%d)\n", i); 
        }
    } 
    return 0;
}

通过惰性评估和二分分解煎熬，小编觉得本身已经逃出生天了，哪知这才刚刚开始，小伙伴们，还请持续关注更新，更多干货和资料请直接联系我，也能够加群710520381，邀请码：柳猫，欢迎你们共同讨论