程序性能优化探讨（2）——循环展开优化详议

        本章的上一节原打算开始讨论优化实例，不曾想被测试工具绊住脚，还好几经折腾已变得可靠，工欲善其事后句内啥，经过思考发现，关于rdtsc指令获得程序模块段运行周期数的方法，还有个小细节需要注意。现在已流行双核四核八核CPU，而rdtsc指令的设计是针对单核的CPU，多核运行时就很难保证精确性。因此我把运行linux的虚拟机设置“处理器”从2改成1，这样模拟原来的单核机，测试效果更佳稳定。

 

一、测试模块搭建

        为了方便测试数据的扩充，教材里使用了结构体来搭建数据结构：

#ifdef FLOAT
typedef float data_t;
#else
#ifdef DOUBLE
typedef double data_t;
#else
#ifdef EXTEND
typedef long double data_t;
#else
typedef int data_t;
#endif /* EXTEND */
#endif /* DOUBLE */
#endif /* FLOAT */

 

#ifdef PROD
#define IDENT 1
#define OPER  *
#else  
#ifdef DIV
#define OPER /
#define IDENT 1
#define OPER_NAME "Divide"
#else
#define IDENT 0
#define OPER  +

        上面的宏定义，咋看有些晕，其实很简单，无非就是用ifdef和else的组合，来确定预编译时的data_t和PROD，他们分别是我们要测试的类型和运算。在运行main函数之前，如果有#define double，那条件判断就会让typedef double data_t;有效，那之后用data_t定义的类型全都是double了。还有PROD也类似，根据应用时的宏定义可以进行加减乘除的运算切换，对不起没有减，哈哈。

typedef struct {
    int len;
    data_t *data;
} vec_rec, *vec_ptr;

 

        教材里要构建向量组，咋一看还以为用链表实现，再一看，根本没有链表指针，实际上这里是在堆里面分配好制定长度的空间，然后用数组的方式进行调用：

vec_ptr new_vec(int len)
{
    /* allocate header structure */
    vec_ptr result = (vec_ptr) malloc(sizeof(vec_rec));
    if (!result)
        return NULL;  /* Couldn't allocate storage */
    result->len = len;

    if (len > 0) {
        data_t *data = (data_t *)calloc(len, sizeof(data_t));
        if (!data) {
            free((void *) result);
            return NULL; /* Couldn't allocate storage */
        }
        result->data = data;
    }  
    else
        result->data = NULL;
    return result;
}

 

        new_vec函数功能是初始化向量组，输入参数len其实就是向量的长度，或者说向量元素的个数，用malloc分配结构体单元空间，然后再用calloc分配len长度的data_t空间，如果len是10，data_t是int，那就分配是个整型变量空间，也就是10*sizeof(int)字节，然后再用结构体里的data指针指向这个空间。其中有很多异常判断代码。

int get_vec_element(vec_ptr v, int index, data_t *dest)
{
    if (index < 0 || index >= v->len)
        return 0;
    *dest = v->data[index];
    return 1;
}

 

int vec_length(vec_ptr v)
{
    return v->len;
}

        上面两个函数意图很明显，获得指定向量组的某个元素值，以及获取指定向量组的长度（元素个数）。有了前面的铺垫，接下来我们给出第一个测试函数：

 

double combine1(vec_ptr v, data_t *dest)
{      
    int i = 0;
    double Start;
    *dest = IDENT;
    start_counter();
    for (; i < vec_length(v); i++) {
        data_t val;
        get_vec_element(v, i, &val);
        *dest = *dest OPER val;
    }  
    Start = get_counter();
    return Start;
}      

        代码的意图很明显，遍历向量组的每个元素，进行累计的OPER操作。从宏定义可获知，当定义为加法时，*dest初始化为0；定义乘除法时定义为1。为了使得测试数据更可靠，我对代码进行部分修改。要消除初始化的周期开销，我把start_counter();get_counter();放在循环的前后，这样只计算循环本身消耗的CPU周期数，把i的初始化放在了定义处。这个修改从combine1到combine6实施。

二、浮点乘法性能测试

        接下来是调用，我们做浮点乘法，索性把6个版本的函数全部放出来：

 

#define DOUBLE
#define PROD

 

int main(int argc, char ** argv)
{  
        double Start, End;
        data_t a;
        vec_ptr v;
        data_t *dest = &a;  
        v = new_vec(atoi(argv[1]));
        Start = combine1(v, dest);