代码优化程序性能
参考自：《深入理解计算机系统》第5章
优化方式：
代码移动(code motion)：识别要执行多次（例如在循环里）但是计算结果不会改变的计算。
减少过程调用：减少循环中的判断。
消除不必要的存储器引用：在临时变量中存放结果，消除每次循环迭代中从存储器中读出并将更新值写回的需要。
循环展开：通过每次迭代计算的元素的数量，减少循环的迭代次数。
提高并行性：利用单元的流水线能力。
重新结合变换：减小计算中关键路径上操作的数量，通过更好地利用功能单元的流水线能力得到更好地性能
vec.h
typedef int data_t;
//typedef double data_t;
/* Create abstract data type for vector */
typedef struct{
long int len;
data_t *data;
}vec_rec, *vec_ptr;
#define IDENT 0
#define OP +
vec_ptr new_vec(long int len);
void free_vec(vec_ptr v);
int get_vec_element(vec_ptr v, long int index, data_t *dest);
long int vec_length(vec_ptr v);
void combine1(vec_ptr v, data_t *dest);
void combine2(vec_ptr v, data_t *dest);
void combine3(vec_ptr v, data_t *dest);
void combine4(vec_ptr v, data_t *dest);
void combine5(vec_ptr v, data_t *dest);
void combine6(vec_ptr v, data_t *dest);
void combine7(vec_ptr v, data_t *dest);
vec.cpp
#include "vec.h"
#include <stdlib.h>
/* Create vector of specified length */
vec_ptr new_vec(long 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;
/* Allocate array */
if (len > 0)
{
data_t *data = (data_t *)calloc(len, sizeof(data_t));
if (!data)
{
free((void *)result);
return NULL;
}
result->data = data;
}
else
{
result->data = NULL;
}
return result;
}
void free_vec(vec_ptr v)
{
if (v)
{
if (v->data)
{
free((void*)v->data);
}
free(v);
}
}
/*
* Retrieve vector element and store at dest.
* Return 0 (out of bounds) or 1 (successful)
*/
int get_vec_element(vec_ptr v, long int index, data_t *dest)
{
if (index < 0 || index >= v->len)
{
return 0;
}
*dest = v->data[index];
return 1;
}
/* Return length of vector */
long int vec_length(vec_ptr v)
{
return v->len;
}
/* Implementation with maximum use of data abstraction */
void combine1(vec_ptr v, data_t *dest)
{
long int i;
*dest = IDENT;
for (i = 0; i < vec_length(v); i++)
{
data_t val;
get_vec_element(v, i, &val);
*dest = *dest OP val;
}
}
// 代码移动(code motion)
/* Move call to vec_length out of loop */
void combine2(vec_ptr v, data_t *dest)
{
long int i;
long int length = vec_length(v);
*dest = IDENT;
for (i = 0; i < length; i++)
{
data_t val;
get_vec_element(v, i, &val);
*dest = *dest OP val;
}
}
data_t *get_vec_start(vec_ptr v)
{
return v->data;
}
// 减少过程调用
/* Direct access to vector data */
void combine3(vec_ptr v, data_t *dest)
{
long int i;
long int length = vec_length(v);
data_t *data = get_vec_start(v);
*dest = IDENT;
for (i = 0; i < length; i++)
{
*dest = *dest OP data[i];
}
}
// 消除不必要的存储器引用
/* Accumulate result in local variable */
void combine4(vec_ptr v, data_t *dest)
{
long int i;
long int length = vec_length(v);
data_t *data = get_vec_start(v);
data_t acc = IDENT;
for (i = 0; i < length; i++)
{
acc = acc OP data[i];
}
*dest = acc;
}
// 循环展开(两次循环展开）
/* Unroll loop by 2 */
void combine5(vec_ptr v, data_t *dest)
{
long int i;
long int length = vec_length(v);
long int limit = length - 1;
data_t *data = get_vec_start(v);
data_t acc = IDENT;
/* Combine 2 elements at a time */
for (i = 0; i < limit; i += 2)
{
acc = (acc OP data[i]) OP data[i + 1];
}
/* Finish any remaining elements */
for (; i < length; i++)
{
acc = acc OP data[i];
}
*dest = acc;
}
// 提高并行性(两路并行）
/* Unroll loop by 2, 2-way parallelism */
void combine6(vec_ptr v, data_t *dest)
{
long int i;
long int length = vec_length(v);
long int limit = length - 1;
data_t *data = get_vec_start(v);
data_t acc0 = IDENT;
data_t acc1 = IDENT;
/* Combine 2 elements at a time */
for (i = 0; i < limit; i += 2)
{
acc0 = acc0 OP data[i];
acc1 = acc1 OP data[i + 1];
}
/* Finish any remaining elements */
for (; i < length; i++)
{
acc0 = acc0 OP data[i];
}
*dest = acc0 OP acc1;
}
// 重新结合变换
/* Change associativity of combining operation */
void combine7(vec_ptr v, data_t *dest)
{
long int i;
long int length = vec_length(v);
long int limit = length - 1;
data_t *data = get_vec_start(v);
data_t acc = IDENT;
/* Combine2 elements at a time */
for (i = 0; i < limit; i += 2)
{
acc = acc OP(data[i] OP data[i + 1]);
}
/* Finish any remaining elements */
for (; i < length; i++)
{
acc = acc OP data[i];
}
*dest = acc;
}
main.cpp
#include <stdio.h>
#include <time.h>
#include "vec.h"
int main()
{
vec_ptr pt = new_vec(10000);
for (int i = 0; i < pt->len; i++)
{
*(pt->data + i) = i + 1;
}
data_t dest;
clock_t start, end;
start = clock();
for (int i = 0; i < 1000; i++)
{
combine1(pt, &dest);
}
end = clock();
printf("1--time:%f----%d\n", (double)(end - start) / CLK_TCK, dest);
start = clock();
for (int i = 0; i < 1000; i++)
{
combine2(pt, &dest);
}
end = clock();
printf("2--time:%f----%d\n", (double)(end - start) / CLK_TCK, dest);
start = clock();
for (int i = 0; i < 1000; i++)
{
combine3(pt, &dest);
}
end = clock();
printf("3--time:%f----%d\n", (double)(end - start) / CLK_TCK, dest);
start = clock();
for (int i = 0; i < 1000; i++)
{
combine4(pt, &dest);
}
end = clock();
printf("4--time:%f----%d\n", (double)(end - start) / CLK_TCK, dest);
start = clock();
for (int i = 0; i < 1000; i++)
{
combine5(pt, &dest);
}
end = clock();
printf("5--time:%f----%d\n", (double)(end - start) / CLK_TCK, dest);
start = clock();
for (int i = 0; i < 1000; i++)
{
combine6(pt, &dest);
}
end = clock();
printf("6--time:%f----%d\n", (double)(end - start) / CLK_TCK, dest);
start = clock();
for (int i = 0; i < 1000; i++)
{
combine7(pt, &dest);
}
end = clock();
printf("7--time:%f----%d\n", (double)(end - start) / CLK_TCK, dest);
free_vec(pt);
return 0;
}
运行结果
