1、空间开销测试：下面的程序测试各种C++结构及其分配内存的空间开销。
//spacemod.cpp: 测试一系列C++结构的空间开销
#include <iostream>
using namespace std;
//空间开销测试的宏版本：先给出结构T的sizeof信息，然后分配11次内存，输出每次的空间开销
#define MEASURE(T,text){ /
cout<<text<<"/t"; /
cout<<sizeof(T)<<"/t"; /
int lastp=0; /
for(int i=0;i<11;i++){ /
T *p=new T; /
int thisp=(int)p; /
if(lastp!=0) /
cout<<" "<<thisp-lastp; /
lastp=thisp; /
} /
cout<<"/n"; /
} /
//函数版本：测试结构T的sizeof信息
template<typename T>
void measure(const char *text){
cout<<"measure: "<<text<<"/t";
cout<<sizeof(T)<<"/n";
}
//定义了十几个结构
struct structc { char c; };
struct structic { int i; char c; };
struct structip { int i; structip *p; };
struct structdc { double d; char c; };
struct structcd { char c; double d; };
struct structcdc { char c1; double d; char c2; };
struct structiii { int i1; int i2; int i3; };
struct structiic { int i1; int i2; char c; };
struct structc12 { char c[12]; };
struct structc13 { char c[13]; };
struct structc28 { char c[28]; };
struct structc29 { char c[29]; };
struct structc44 { char c[44]; };
struct structc45 { char c[45]; };
struct structc60 { char c[60]; };
struct structc61 { char c[61]; };
int main(){
//对基本结构进行空间度量
cout << "Raw sizeof";
cout << "/nsizeof(char)=" << sizeof(char);
cout << " sizeof(short)=" << sizeof(short);
cout << " sizeof(int)=" << sizeof(int);
cout << "/nsizeof(float)=" << sizeof(float);
cout << " sizeof(struct *)=" << sizeof(structc *);
cout << " sizeof(long)=" << sizeof(long);
cout << "/nsizeof(double)=" << sizeof(double);
//测试各个结构的空间开销
cout << "/n/nMEASURE macro/n";
MEASURE(int, "int");
MEASURE(structc, "structc");
MEASURE(structic, "structic");
MEASURE(structip, "structip");
MEASURE(structdc, "structdc");
MEASURE(structcd, "structcd");
MEASURE(structcdc, "structcdc");
MEASURE(structiii, "structiii");
MEASURE(structiic, "structiic");
MEASURE(structc12, "structc12");
MEASURE(structc13, "structc13");
MEASURE(structc28, "structc28");
MEASURE(structc29, "structc29");
MEASURE(structc44, "structc44");
MEASURE(structc45, "structc45");
MEASURE(structc60, "structc60");
MEASURE(structc61, "structc61");
//用函数模板来测试结构的sizeof信息，与上面测试结果进行比较
cout << "/nmeasure template/n";
measure<int>("int");
measure<structc>("structc");
measure<structic>("structic");
return 0;
}在32位的Windows 7上用gcc 4.4.1编译执行的结果：
C:/cpp>g++ spacemod.cpp -o spacemod
C:/cpp>spacemod
Raw sizeof
sizeof(char)=1 sizeof(short)=2 sizeof(int)=4
sizeof(float)=4 sizeof(struct *)=4 sizeof(long)=4
sizeof(double)=8
MEASURE macro
int 4 120 16 16 16 16 16 16 16 16 16
structc 1 16 16 16 16 16 20864 16 16 16 16
structic 8 16 16 16 16 16 16 16 16 16 16
structip 8 16 16 16 16 16 16 16 16 16 16
structdc 16 24 24 24 24 24 24 24 24 24 24
structcd 16 24 24 24 24 24 22512 24 24 24 24
structcdc 24 32 32 32 32 32 32 32 32 32 32
structiii 12 24 24 24 24 24 24 24 24 24 24
structiic 12 24 24 24 24 24 24 24 24 24 24
structc12 12 24 24 24 24 24 24 24 24 24 24
structc13 13 24 24 1022616 24 24 24 24 24 24 24
structc28 28 40 40 40 23016 40 40 40 40 40 40
structc29 29 40 40 40 40 40 1023120 40 40 40 40
structc44 44 1025104 56 56 56 56 56 56 56 56 56
structc45 45 56 56 56 56 80 56 56 56 56 56
structc60 60 72 -1028008 72 72 72 72 72 72 72 72
structc61 61 72 72 72 72 72 96 72 72 72 72
measure template
measure: int 4
measure: structc 1
measure: structic 82、时间开销测试：下面程序测试一系列C运算的时间开销。由于基本运算的执行时间非常短，我们对一个运算执行多遍，每遍执行n*n次（n比较大），输出每一遍总的时间开销，最后算出一次运算的平均时间开销。用平均时间开销能更好的反映运算的时间消耗。
//timemod.c：测试一系列C运算的时间开销
#include <stdio.h>
#include <time.h>
#include <stdlib.h>
#include <math.h>
#define MAXN 100000
int x[MAXN];
int startn = 5000;
int n;
/* 比较操作：用减法运算来比较的函数版本 */
int intcmp(int *i, int *j)
{ return *i - *j; }
/* 交换操作：宏版本和函数版本 */
#define swapmac(i, j) { t = x[i]; x[i] = x[j]; x[j] = t; }
void swapfunc(int i, int j){
int t = x[i];
x[i] = x[j];
x[j] = t;
}
/* max操作：宏版本和函数版本 */
#define maxmac(a, b) ((a) > (b) ? (a) : (b))
int maxfunc(int a, int b)
{ return a > b ? a : b; }
/* 测试各种运算的时间开销：进行5遍运算，每一遍执行运算i op j共n*n次（i,j分别从1遍历到n），
输出每一遍的时间开销。最后输出一次i op j运算的平均时间开销，以纳称为单位。
注意这里两次clock()函数调用之差除以CLOCKS_PER_SEC即得秒数开销，乘以10**9既得纳秒数开销
*/
#define T(s) printf("%s (n=%d)/n", s, n);
#define TRIALS 5
#define M(op) /
printf(" %-22s", #op); /
k = 0; /
timesum = 0; /
for (ex = 0; ex < TRIALS; ex++) { /
start = clock(); /
for (i = 1; i <= n; i++) { /
fi = (float) i; /
for (j = 1; j <= n; j++) { /
op; /
} /
} /
t = clock()-start; /
printf("%6d", t); /
timesum += t; /
} /
nans = 1e9 * timesum / ((double) /
n*n * TRIALS * CLOCKS_PER_SEC); /
printf("/t%8.0f/n", nans);
int main()
{ int i, j, k;
float fi, fj, fk;
int t, ex, timesum, start, globalstart;
double nans;
globalstart = clock();
for (i = 0; i < n; i++)
x[i] = rand(); /* 用随机数初始化要测试的数组 */
n = startn;
printf("C Time Cost Model, n=%d/n", n);
/* 测试整数运算的时间开销 */
T("Integer Arithmetic");
M({}); /* 测试空循环运算*/
M(k++); /* 测试整数自加运算 */
M(k = i + j); /* 加法运算 */
M(k = i - j);
M(k = i * j);
M(k = i / j);
M(k = i % j);
M(k = i & j);
M(k = i | j);
/* 测试浮点数运算的时间开销 */
T("Floating Point Arithmetic");
M(fj=j;);
M(fj=j; fk = fi + fj;);
M(fj=j; fk = fi - fj;);
M(fj=j; fk = fi * fj;);
M(fj=j; fk = fi / fj;);
/* 测试数组运算及比较的时间开销 */
T("Array Operations");
M(k = i + j);
M(k = x[i] + j);
M(k = i + x[j]);
M(k = x[i] + x[j]);
T("Comparisons");
M(if (i < j) k++); /* 比较操作 */
M(if (x[i] < x[j]) k++);
/* 测试各种比较和交换操作的时间开销 */
T("Array Comparisons and Swaps");
M(k = (x[i]<x[k]) ? -1:1); /* 比较操作的内联版本 */
M(k = intcmp(x+i, x+j)); /* 比较操作的减法版本 */
M(swapmac(i, j)); /* 交换操作的宏版本 */
M(swapfunc(i, j)); /* 交换操作的函数版本 */
/* 测试max操作的内联、宏和函数版本的时间开销 */
T("Max Function, Macro and Inline");
M(k = (i > j) ? i : j);
M(k = maxmac(i, j));
M(k = maxfunc(i, j));
n = startn / 5;
/* 测试数学函数的执行时间开销 */
T("Math Functions");
M(fk = j+fi;);
M(k = rand(););
M(fk = sqrt(j+fi));
M(fk = sin(j+fi));
M(fk = sinh(j+fi));
M(fk = asin(j+fi));
M(fk = cos(j+fi));
M(fk = tan(j+fi));
/* 测试内存分配函数的时间开销 */
n = startn / 10;
T("Memory Allocation");
M(free(malloc(16)););
M(free(malloc(100)););
M(free(malloc(2000)););
/* 上述所有运算总的时间开销，单位为秒 */
printf(" Secs: %4.2f/n",
((double) clock()-globalstart)
/ CLOCKS_PER_SEC);
return 0;
}在32位的Windows 7上用gcc 4.4.1编译执行的结果：
C:/cpp>gcc timemod.c -o timemod
C:/cpp>timemod
C Time Cost Model, n=5000
Integer Arithmetic (n=5000)
{} 78 61 61 61 61 3
k++ 60 60 60 60 60 2
k = i + j 60 60 60 60 60 2
k = i - j 85 85 85 85 85 3
k = i * j 63 65 64 64 64 3
k = i / j 80 80 80 80 79 3
k = i % j 79 79 79 79 79 3
k = i & j 60 60 60 60 60 2
k = i | j 60 60 60 60 60 2
Floating Point Arithmetic (n=5000)
fj=j; 69 69 69 69 69 3
fj=j; fk = fi + fj; 68 69 69 69 68 3
fj=j; fk = fi - fj; 69 68 68 68 69 3
fj=j; fk = fi * fj; 70 70 69 70 70 3
fj=j; fk = fi / fj; 188 188 189 188 189 8
Array Operations (n=5000)
k = i + j 60 60 60 60 61 2
k = x[i] + j 59 59 59 58 58 2
k = i + x[j] 62 62 62 62 62 2
k = x[i] + x[j] 62 62 62 62 62 2
Comparisons (n=5000)
if (i < j) k++ 58 58 58 58 58 2
if (x[i] < x[j]) k++ 63 62 62 62 63 2
Array Comparisons and Swaps (n=5000)
k = (x[i]<x[k]) ? -1:1 61 62 61 62 61 2
k = intcmp(x+i, x+j) 117 118 117 117 118 5
swapmac(i, j) 106 106 106 105 105 4
swapfunc(i, j) 142 142 142 142 143 6
Max Function, Macro and Inline (n=5000)
k = (i > j) ? i : j 58 59 58 58 59 2
k = maxmac(i, j) 59 58 59 58 58 2
k = maxfunc(i, j) 100 99 99 99 99 4
Math Functions (n=1000)
fk = j+fi; 2 1 1 1 1 1
k = rand(); 16 16 16 16 16 16
fk = sqrt(j+fi) 8 9 8 8 8 8
fk = sin(j+fi) 90 93 93 97 90 93
fk = sinh(j+fi) 374 375 375 376 375 375
fk = asin(j+fi) 171 174 171 171 172 172
fk = cos(j+fi) 90 95 95 91 95 93
fk = tan(j+fi) 105 105 107 104 107 106
Memory Allocation (n=500)
free(malloc(16)); 75 75 75 74 75 299
free(malloc(100)); 74 75 73 74 74 296
free(malloc(2000)); 67 67 67 67 67 268
Secs: 15.87每一行的前5个数表示5遍中每一遍的总运行时间开销，每一遍中执行该运算共n*n次。最后一个数给出了以纳秒为单位的每个运算的平均时间开销。从中可以看出整数、浮点数和数组运算的开销都不大，比较和交换的宏版本、内联版本比函数版本速度更快，由于这些函数非常简单，因此开销都不大。三角函数的开销大了差不多两个数量级，内存分配的开销也比较大。
941
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
