/*mbw.c源码格函数解析*/

/*allocate a test array and fill it with data * so as to force Linux to _really_ allocate it*/

long *make_array(unsigned long longasize)

{

unsignedlong longt;

unsignedint long_size=sizeof(long);long *a;//calloc是一个ISO C函数函数名： calloc函数原型：void *calloc(size_t n, size_t size)；功 能： 在内存的动态存储区中分配n个长度为size的连续空间，函数返回一个指向分配起始地址的指针；如果分配不成功，返回NULL。

a=calloc(asize, long_size);if(NULL==a) {

perror("Error allocating memory");

exit(1);

}/*make sure both arrays are allocated, fill with pattern*/

for(t=0; t

a[t]=0xaa;

}returna;

}=============================

/*actual benchmark*/

/*asize: number of type ‘long‘ elements in test arrays //测试数组中long型元素个数

* long_size: sizeof(long) cached //long型内存大小，即占几个字节

* type: 0=use memcpy, 1=use dumb copy loop (whatever GCC thinks best)

*

* return value: elapsed time in seconds*/

double worker(unsigned long long asize, long *a, long *b, int type, unsigned long longblock_size)

{

unsignedlong longt;struct timeval starttime, endtime; //timeval结构体定义在time.h中，具体解析http://blog.csdn.net/yusiguyuan/article/details/21781839

doublete;

unsignedint long_size=sizeof(long);/*array size in bytes*/unsignedlong long array_bytes=asize*long_size;if(type==1) { /*memcpy test*/

/*timer starts*/gettimeofday(&starttime, NULL);//记录开始时间

memcpy(b, a, array_bytes);//拷贝array_bytes大小 内存

/*timer stops*/gettimeofday(&endtime, NULL);//记录结束时间

} else if(type==2) { /*memcpy block test*/gettimeofday(&starttime, NULL);for(t=0; t

b=mempcpy(b, a, block_size);//void *memccpy(void *dest, const void *src, int c, size_t n);在两块不重叠的内存地址间复制内容，直至复制了n字节或遇到内容为c的字节

}if(t>array_bytes) {

b=mempcpy(b, a, t-array_bytes);

}

gettimeofday(&endtime, NULL);

}else { /*dumb test*/ // gettimeofday(&starttime, NULL);for(t=0; t

b[t]=a[t];

}

gettimeofday(&endtime, NULL);

}

te=((double)(endtime.tv_sec*1000000-starttime.tv_sec*1000000+endtime.tv_usec-starttime.tv_usec))/1000000;returnte;

}/*------------------------------------------------------*/

/*pretty print worker‘s output in human-readable terms*/

/*te: elapsed time in seconds

* mt: amount of transferred data in MiB

* type: see ‘worker‘ above

*

* return value: -*/

void printout(double te, double mt, inttype)

{switch(type) {case 0:

printf("Method: MEMCPY\t");break;case 1:

printf("Method: DUMB\t");break;case 2:

printf("Method: MCBLOCK\t");break;

}

printf("Elapsed: %.5f\t", te);

printf("MiB: %.5f\t", mt);

printf("Copy: %.3f MiB/s\n", mt/te);return;

}/*------------------------------------------------------*/

int main(int argc, char **argv)

{

unsignedint long_size=0;double te, te_sum; /*time elapsed*/unsignedlong long asize=0; /*array size (elements in array)*/

inti;long *a, *b; /*the two arrays to be copied from/to*/

int o; /*getopt options*/unsignedlongtestno;/*options*/

/*how many runs to average?*/

int nr_loops=DEFAULT_NR_LOOPS;/*fixed memcpy block size for -t2*/unsignedlong long block_size=DEFAULT_BLOCK_SIZE;/*show average, -a*/

int showavg=1;/*what tests to run (-t x)*/

inttests[MAX_TESTS];double mt=0; /*MiBytes transferred == array size in MiB*/

int quiet=0; /*suppress extra messages*/tests[0]=0;

tests[1]=0;

tests[2]=0;while((o=getopt(argc, argv, "haqn:t:b:")) !=EOF) {switch(o) {case ‘h‘:

usage();

exit(1);break;case ‘a‘: /*suppress printing average*/showavg=0;break;case ‘n‘: /*no. loops*/nr_loops=strtoul(optarg, (char **)NULL, 10);break;case ‘t‘: /*test to run*/testno=strtoul(optarg, (char **)NULL, 10);if(0>testno) {

printf("Error: test number must be between 0 and %d\n", MAX_TESTS);

exit(1);

}

tests[testno]=1;break;case ‘b‘: /*block size in bytes*/block_size=strtoull(optarg, (char **)NULL, 10);if(0>=block_size) {

printf("Error: what block size do you mean?\n");

exit(1);

}break;case ‘q‘: /*quiet*/quiet=1;break;default:break;

}

}/*default is to run all tests if no specific tests were requested*/

if( (tests[0]+tests[1]+tests[2]) == 0) {

tests[0]=1;

tests[1]=1;

tests[2]=1;

}if(optind

mt=strtoul(argv[optind++], (char **)NULL, 10);

}else{

printf("Error: no array size given!\n");

exit(1);

}if(0>=mt) {

printf("Error: array size wrong!\n");

exit(1);

}/*------------------------------------------------------*/long_size=sizeof(long); /*the size of long on this platform*/asize=1024*1024/long_size*mt; /*how many longs then in one array?*/

if(asize*long_size

printf("Error: array size larger than block size (%llu bytes)!\n", block_size);

exit(1);

}if(!quiet) {

printf("Long uses %d bytes.", long_size);

printf("Allocating 2*%lld elements = %lld bytes of memory.\n", asize, 2*asize*long_size);if(tests[2]) {

printf("Using %lld bytes as blocks for memcpy block copy test.\n", block_size);

}

}

a=make_array(asize);

b=make_array(asize);/*------------------------------------------------------*/

if(!quiet) {

printf("Getting down to business... Doing %d runs per test.\n", nr_loops);

}/*run all tests requested, the proper number of times*/

for(testno=0; testno

te_sum=0;if(tests[testno]) {for (i=0; i

te=worker(asize, a, b, testno, block_size);

te_sum+=te;

printf("%d\t", i);

printout(te, mt, testno);

}if(showavg) {

printf("AVG\t");

printout(te_sum/nr_loops, mt, testno);

}

}

}free(a);free(b);return 0;

}