代码改变世界

《编程珠玑,字字珠玑》910读书笔记——代码优化

2012-04-15 13:39  捣乱小子  阅读(...)  评论(...编辑  收藏

写在最前面的

再庞大复杂的代码编译器都能接受,编译器会变得越来越聪明,让我们原本的代码更加高效。但是代码执行的多变与不可预测性,如果编译器大肆“优化”,偶尔或者大胆的说“在大多数情况下”,会得到“聪明反被聪明误”的后果,所以编译器非常小心谨慎,一遇到不可预测后果的优化,它就会立即折返,停止这一步的优化工作,因为它不知道程序员的本意是什么,“它怕得罪你”。
程序员要编写容易优化的代码,以帮助编译器扫清障碍。关于代码优化,笔者特别喜欢《深入理解计算机系统》一书中的第五章,有兴趣的可以阅读一下。

代码优化小剖 

代码优化的方法总结了5种。

  • 将函数展开,即内敛函数,以优化函数的调用。 从简单的算法初探过程汇编》,过多的函数调用会导致极大的调用开销。所以,简单而且时常调用的函数建议内敛,例如swap,max,min。改用宏或者直接展开函数更好。 

  • 消除循环的低效率
    这一点我感触比较深。
    toupper(* str)
        for i=[0,strlen(str))
            if(str[i]>='a' && str[i]<='z')
                str[i] += ('A'-'a')

    strlen的源码大概如下:

    strlen(* str) 
        len = 0
        while(*s!='\0')
            s++,len++
        return len
    所以toupper中对i的每一次检测,都调用了strlen,由此可见toupper的浪费由来。以前写程序一直采用上面的toupper,以为够简洁,就像第三点中的sum伪代码。  

  • 减少不必要的存储器引用
    sum(* src,n,* dest)    //    src向量相加结果放入dest
        for i=[0,n)
            *dest += src + i
    代码如此简洁而有力,以前一直为这种风格而自豪。但它的缺点也是显然的,循环内部过多的引用dest地址:每次循环都要把dest地址内的数据取出到寄存器接,寄存器相加得到结果后,又从寄存器写入到dest地址,所以dest读n次,写n次。这有何必呢?读写浪费很浪费,下面的代码会不会好点:  
    sum(* src,n,* dest)    //    src向量相加结果放入dest
        temp = *dest;
        for i=[0,n)
            temp += src + i
        *dest = temp

  • 循环展开 
    引用《深入理解》P348 "首先,它减少了不直接有助于程序结果的操作的数量,例如循环索引计算和条件分支。其次,它提供了一些方法(重结合变换),可以进一步变化代码,减少整个计算中关键路径上的操作数量。"关键路径,书上对它的解释是执行一组机器指令所需时钟周期的一个下界。比如乘法和加法的周期,乘法就应该成为这组执行机器指令的关键路径。  

    什么是循环开销?比如:
    for i=(0,n]
    每一循环的开始都要对i做判断,以及对i自增,所以循环展开能降低这些开销。二路循环展开的伪代码:
    sum(* src,n,* dest)    //    src向量相加结果放入dest
        temp = *dest
        for i=[0,n-2+1),i+=2
            temp += src+i + src+i+1
        for i=[i,n),i+=1
            temp += src+i

    但是浮点的乘法没有得到效率的提高,是因为浮点乘法这个关键路径是循环展开的限制因素,即使循环展开,也需要执行n次的乘法。而有疑问,为什么整数乘法就能得到提高呢,那是因为编译器作了“重关联变换”的优化,改变了乘法的结合顺序(有兴趣看看下面的第6点,我带过了)。又有疑问了,为什么浮点不能作想整数乘法这样的优化呢?因为浮点乘法加法是不可结合的,记住“编译器怕得罪你”。 
    珠玑中第九章的顺序搜索就是用了这种优化。 

  • 多个累积变量
    这是提高并行操作的方法,同时达到了循环展开的效果。 
    sum(* src,n,* dest)    //    src向量相加结果放入dest
        temp1 = *dest
        temp2 = 0
        for i=[0,n-2+1),i+=2
            temp1 += src+i    //    提高并行性,temp1和temp2可以并行计算而毫不牵连
            temp2 += src+i+1
        for i=[i,n),i+=1
            temp += src+i
        *dest = temp1+temp2
    //temp1和temp2的加法操作是两条关键路径,而两条关键路径各执行了n/2个操作。 
    同样,乘法也能得到效率的提高。注意循环寄存器有两个,数据相关降低,两个循环寄存器的运算是并行的。

 

关于第六种优化方法——重新结合变换 

书上还有说第六种优化——重新结合变换,如果大胆对浮点运算进行此类优化,性能有很大的提高。之所以没有标号,是因为笔者也不太能说清楚,说说笔者的理解。

sum(* src,n,* dest)    //    src向量相加结果放入dest
    temp = *dest
    for i=[0,n-2+1),i+=2
        temp = temp * (src+i * src+i+1)    //    假设原来是temp = (temp * src+i) * src+i+1
    for i=[i,n),i+=1
        temp += src+i

 

我的理解可以结合下图,下图是乘法的图,同样可以换成加法的图:

注意是temp = temp * (src+i * src+i+1)的图,而不是temp = (temp * src+i) * src+i+1的图,后者大家可以自己手动画画。

image 

哈哈,书上说:未经训练的人员,上面的两条语句是一样的,“捣乱笑而不语啊!”我的理解是虽然循环寄存器只有一个,但是temp = temp * (src+i * src+i+1)中(src+i * src+i+1)的计算不依赖于循环寄存器的值即temp的值,而temp = (temp * src+i) * src+i+1会对temp产生依赖,结合顺序会对循环寄存器进行产生依赖,因此前者可以增加计算的并行性。 

神马?什么是循环寄存器?对于某些循环来说,有些寄存器既作为源值又作为目的,一次循环的结果会在下一次循环中用到。循环寄存器之间的关联越大,那么,这种关联将是性能提升的瓶颈。 

简单举个例子:

sum(* src,n,* dest)    //    src向量相加结果放入dest
    temp = *dest;
    for i=[0,n)
        temp += src + i
    *dest = temp

那么temp所在寄存器就是所谓的“循环寄存器”,它使得每一次循环都有很大的关联,所以,temp的加法操作(抑或是乘法操作)是关键路径,这也就是为什么累积变量能够提高程序的性能,它有两个循环寄存器,降低了循环关联。 

    《珠玑》第九章的代码优化,印象比较深的:

  1.     整数取模 
  2.     函数内敛 
  3.     循环展开 

跟上面的内容差不多。 

关于哨兵

哨兵就是能帮助程序检测数组边界的东西,简化了数组边界的检测,从而使代码更加清晰简便。记得一开始接触哨兵是在顺序表查找的时候。

search(* arr,n,data)
    arr[n] = data
    for i=[0,n)    arr[i]!=data    //肯定会遇到data
        do nothing in for
    if(i==n)    return -1
    return i;

再来就是直接插入排序;如果不设置哨兵,不仅要检测下标是否下溢,而且要检测只有当满足arr[j]>data,才后移,这里会有两个判断。

insert_sort
    for i=[0,n)
        if arr[i]>arr[i+1]
            arr[0] = arr[i+1]                    //哨兵
            for j=[i+1)    arr[j]>arr[0]        //相比常规版本,只做n次判断。
                arr[j] = a[j-1],j--
            arr[j+1] = arr[0]

另外,用单链表存储一组顺序数据,对于这种问题,一般的单链表插入,都要考虑头插法和尾插法的情况,其他情况的代码可以是一致的;如果能够为单链表的最后添加哨兵,应该可以很大程度上简化代码。下面的代码比一般的单链表插入简洁而且应该更高效:

pre_insert:把maxval放置链表的最后
insert(* first,data)
    p = first->next
    while(p)
        if data < q->data
            end while
        p = p->next;
    p = new node(data,p)

《珠玑》第9章第8小题,“如何在程序中使用哨兵来找出数组中的最大元素”?
如果没有“哨兵”,大致的想法就是用一个变量max来存储数组的第一个值,然后从第二个开始“逐个”检验是否>max。加上循环中的下标检验,共有2n次的检测。
放置哨兵的做法:在数组的最后放置“已经找到的最大的元素”,然后逐个检验,

find_max(* arr)
    i = 0
    max = arr[i]
    while(i!=n)
        max = arr[i]
        arr[n] = max
        i++
        while(arr[i]<max)    //因为有哨兵的存在,此循环必定可以终结。
            i++

除非arr是严格递增或者每个元素值相等,否则总的检测次数会<2n。总之在考虑边界检测的时候,不妨考虑下用在边界上放置哨兵来简化清晰代码。

 

总结 

不知道这些优化,在以后的做题能不能奏效了。对于一些程序,笔者认为上面的优化是无关痛痒的,或许编程的技巧会更突显重要性,当完成了大部分程序,而后考虑上面的优化也不为过;但养成“优化”的习惯不失为一个优秀程序员的品质。(以上是笔者的学习笔记,需要更深入了解上面的内容,阅读原著或许收益更多。)关于珠玑的第十章,笔者实在无能为力 - =,只写了第九章。


本文完 Sunday, April 15, 2012 

捣乱小子 http://daoluanxiaozi.cnblogs.com/