最近又重新翻看了《编程珠玑》这本书，里面着重对工程化处理进行了讲解，写得很好。印象最深的一个例子，作者拿布鲁克林大桥举例，20世纪40年代前，有很多悬索桥会因为风暴断裂。而要对这种气动上升现象做正确的数学建模和工程计算，要等到10年后。而同一时期的布鲁克林大桥却没有断裂，工程师John Roebling说，他知道气动上升现象的存在，但是又无法从本质上去正确处理它（建模），于是他按照所需强度的6倍设计了大桥。最后作者建议我们，以2、4或6的系数来降低对性能的估计。其实就是要预留足够的性能。作者最后说：“我们是和John Roebling一样的工程师吗？我很怀疑”。
言归正传，书中提到了时空开销模型，用于对代码中时空开销做计算，可以方便的用于代码性能估计和代码优化。本文对此代码做了整理，可以加入到utils库中，并且可在ESP32和STM32F103C8上运行。
基本类型的空间占用
#define SIZE_MEASURE(T) \
do { \
printf("sizeof(%s)=%d\n", #T, sizeof(T));
\
} while (0)void platform_base_type_size_measure(void)
{
printf("\nplatform_base_type_size_measure\n");
SIZE_MEASURE(char);
SIZE_MEASURE(short);
SIZE_MEASURE(int);
SIZE_MEASURE(long);
SIZE_MEASURE(long long);
SIZE_MEASURE(float);
SIZE_MEASURE(double);
SIZE_MEASURE(int*);
}这里用到了前面的知识点，宏定义参数前加#，可以转换为字符串。
结果：
platform_base_type_size_measure
sizeof(char)=1
sizeof(short)=2
sizeof(int)=4
sizeof(long)=4
sizeof(long long)=8
sizeof(float)=4
sizeof(double)=8
sizeof(int*)=4因为esp32和stm32都是32位平台，所以int是4字节，指针也是4字节。
结构体对齐和malloc占用空间
typedef struct{char c;
} structc;
typedef struct {int i;
char c;
} structic;
typedef struct {int i;
struct structip *p;
} structip;
typedef struct {double d;
char c;
} structdc;
typedef struct {char c;
double d;
} structcd;
typedef struct {char c;
double d;
char cc;
} structcdc;
typedef struct {int i;
int ii;
int iii;
} structiii;
typedef struct {int i;
int ii;
char c;
} structiic;
typedef struct {char c[12];
} struct12;
typedef struct {char c[13];
} struct13;
typedef struct {char c[28];
} struct28;
typedef struct {char c[29];
} struct29;
#define SIZE_MALLOC_MEASURE(T) \
do { \
printf("%s%c\t", #T, strlen(#T)<8?'\t':' ');
\
printf("%d\t", sizeof(T));
\
int lastp = 0;
\
for(int i=0;
i<11;
i++) { \
T* p = (T*)malloc(sizeof(T));
\
uint32_t thisp = (uint32_t)p;
\
if(lastp != 0) \
printf(" %d", thisp - lastp);
\
lastp = thisp;
\
} \
printf("\n");
\
} while (0)void platform_struct_size_measure(void)
{
printf("\nstruct\t\tsizeof\t malloc size\n");
SIZE_MALLOC_MEASURE(int);
SIZE_MALLOC_MEASURE(structc);
SIZE_MALLOC_MEASURE(structic);
SIZE_MALLOC_MEASURE(structip);
SIZE_MALLOC_MEASURE(structdc);
SIZE_MALLOC_MEASURE(structcd);
SIZE_MALLOC_MEASURE(structcdc);
SIZE_MALLOC_MEASURE(structiii);
SIZE_MALLOC_MEASURE(structiic);
SIZE_MALLOC_MEASURE(struct12);
SIZE_MALLOC_MEASURE(struct13);
SIZE_MALLOC_MEASURE(struct28);
SIZE_MALLOC_MEASURE(struct29);
}命名规则为：c:chart i:int d:double，并且互相拼接。
结果：
structsizeofmalloc size
int416 267900 16 16 16 16 16 16 16 16
structc116 16 16 16 16 16 16 16 16 16
structic816 16 16 16 16 16 16 16 16 16
structip816 16 16 16 16 16 16 16 16 16
structdc1620 20 20 20 20 524 20 20 20 20
structcd1620 20 20 20 20 20 20 20 20 20
structcdc2428 28 28 28 28 28 28 28 28 28
structiii1216 16 16 16 16 16 16 16 16 16
structiic1216 16 16 16 16 16 16 16 16 16
struct121216 16 16 16 16 16 16 16 16 16
struct131320 20 20 20 20 20 20 20 20 20
struct282832 32 32 32 32 32 32 32 32 32
struct292936 36 36 36 36 36 36 36 36 36可以看到，结构体会进行对齐补全，有double会补齐8字节。所以想在通信代码中通过结构体转换协议，记得使用#pragma pack(1)按1字节对齐。
malloc在申请内存时，也会有多余的空间占用，并且不一定是线性增长，这与malloc的实现方式有关。
整形运算符时间消耗
#define INT_TIME_MEASURE(OP, n) \
do { \
printf("%s%c\t", #OP, strlen(#OP)<8?'\t':' ');
\
int64_t timesum = 0;
\
for(int ttt=0;
ttt<5;
ttt++) { \
int64_t start = esp_timer_get_time();
\
for(int i=1;
i<=n;
i++) { \
for(int j=1;
j<=n;
j++) { \
OP;
\
} \
} \
int64_t t = esp_timer_get_time() - start;
\
printf("%lld ", t);
\
timesum += t;
\
} \
printf("\t%lld\n", 1000*timesum / (n*n*5));
\
} while (0)void platform_int_time_measure(void)
{
int loop_n = 500;
printf("\nplatform_int_time_measure (n=%d)\n", loop_n);
printf("oprate\t\ttime(us)\t\ttime avg(ns)\n");
volatile int k = 0;
INT_TIME_MEASURE({}, loop_n);
INT_TIME_MEASURE(k++, loop_n);
INT_TIME_MEASURE(k=i+j, loop_n);
INT_TIME_MEASURE(k=i-j, loop_n);
INT_TIME_MEASURE(k=i*j, loop_n);
INT_TIME_MEASURE(k=i/j, loop_n);
INT_TIME_MEASURE(k=i%j, loop_n);
INT_TIME_MEASURE(k=i&j, loop_n);
INT_TIME_MEASURE(k=i|j, loop_n);
}因为涉及到时间计算，得使用计时函数，这里是ESP32的实现方式。由于运行速度很快，定时器分辨率不高，所以采用多次运行取平均值的方式。
结果：
//ESP32
platform_int_time_measure (n=500)
opratetime(us)time avg(ns)
{}1 1 1 1 10
k++11473 11475 11471 11471 1147145
k=i+j7306 7305 7301 7305 730529
k=i-j7302 7305 7304 7305 730129
k=i*j9390 9390 9390 9390 939037
k=i/j9621 9620 9620 9621 962138
k=i%j10664 10663 10662 10662 1066242
k=i&j8347 8346 8346 8346 834333
k=i|j8347 8346 8347 8346 834633//STM32F103C8
platform_int_time_measure (n=500)
opratetime(us)time avg(ns)
{}27290 27290 27280 27280 27290109
k++39150 39150 39150 39150 39150156
k=i+j39060 39060 39070 39070 39070156
k=i-j35110 35110 35110 35110 35100140
k=i*j35180 35180 35180 35180 35180140
k=i/j44410 44410 44410 44410 44410177
k=i%j63790 63790 63790 63790 63790255
k=i&j39060 39070 39070 39060 39060156
k=i|j46820 46820 46820 46820 46830187ESP32的自增运算比较耗时，有点奇怪。STM32上自增和加法是一样的。
ESP32的除法没有更耗时，STM32的除法是更耗时的。
平时没注意到的是，求余运算非常耗时。与运算也不能说省时间。
浮点运算符时间消耗
#define FLOAT_TIME_MEASURE(OP, n) \
do { \
printf("%s%c\t", #OP, strlen(#OP)<8?'\t':' ');
\
int64_t timesum = 0;
\
volatile float fi,fj;
\
for(int ttt=0;
ttt<5;
ttt++) { \
int64_t start = esp_timer_get_time();
\
for(int i=1;
i<=n;
i++) { \
fi = i;
\
for(int j=1;
j<=n;
j++) { \
fj = j;
\
OP;
\
} \
} \
int64_t t = esp_timer_get_time() - start;
\
printf("%lld ", t);
\
timesum += t;
\
} \
printf("\t%lld\n", 1000*timesum / (n*n*5));
\
} while (0)void platform_float_time_measure(void)
{
int loop_n = 100;
printf("\nplatform_float_time_measure (n=%d)\n", loop_n);
printf("oprate\t\ttime(us)\t\ttime avg(ns)\n");
volatile float fk = 0;
FLOAT_TIME_MEASURE({}, loop_n);
FLOAT_TIME_MEASURE(fk=fi+fj, loop_n);
FLOAT_TIME_MEASURE(fk=fi-fj, loop_n);
FLOAT_TIME_MEASURE(fk=fi*fj, loop_n);
FLOAT_TIME_MEASURE(fk=fi/fj, loop_n);
}结果：
//ESP32
platform_float_time_measure (n=100)
opratetime(us)time avg(ns)
{}1685 1683 1683 1683 1683168
fk=fi+fj3941 3935 3939 3936 3935393
fk=fi-fj4516 4511 4514 4510 4514451
fk=fi*fj4293 4291 4295 4291 4295429
fk=fi/fj14036 14037 14034 14033 140371403//STM32
platform_float_time_measure (n=100)
opratetime(us)time avg(ns)
{}6000 6010 6000 6000 6010600
fk=fi+fj15670 15680 15680 15680 156801567
fk=fi-fj14760 14760 14760 14760 147601476
fk=fi*fj13920 13920 13920 13920 139201392
fk=fi/fj20790 20790 20790 20790 207902079过程中需要先将整数赋值给浮点，消耗了不少时间。所以需要减去空运行的时间。即使是带FPU的ESP32，依然消耗不少时间。
数组运算符时间消耗
void platform_array_time_measure(void)
{
int loop_n = 500;
printf("\nplatform_array_time_measure (n=%d)\n", loop_n);
printf("oprate\t\ttime(us)\t\ttime avg(ns)\n");
volatile int k = 0;
int x[loop_n+1];
INT_TIME_MEASURE(k=i+j, loop_n);
INT_TIME_MEASURE(k=x[i]+j, loop_n);
INT_TIME_MEASURE(k=i+x[j], loop_n);
INT_TIME_MEASURE(k=x[i]+x[j], loop_n);
}直接使用整数的宏，结果和整数操作差异不大
platform_array_time_measure (n=500)
opratetime(us)time avg(ns)
k=i+j7302 7304 7304 7301 730429
k=x[i]+j7313 7313 7309 7312 731329
k=i+x[j]10431 10429 10430 10430 1043041
k=x[i]+x[j]10432 10432 10432 10432 1043241操作符和数学库时间消耗
void platform_function_time_measure(void)
{
int loop_n = 100;
printf("\nplatform_function_time_measure (n=%d)\n", loop_n);
printf("oprate\t\ttime(us)\t\ttime avg(ns)\n");
volatile int k = 0;
volatile float fk = 0;
INT_TIME_MEASURE(k=(i>j)?i:j, loop_n);
INT_TIME_MEASURE(rand(), loop_n);
FLOAT_TIME_MEASURE(fk=sqrt(j+fi), loop_n);
FLOAT_TIME_MEASURE(fk=sin(j+fi), loop_n);
// FLOAT_TIME_MEASURE(fk=sinh(j+fi), loop_n);
// FLOAT_TIME_MEASURE(fk=asin(j+fi), loop_n);
// FLOAT_TIME_MEASURE(fk=cos(j+fi), loop_n);
// FLOAT_TIME_MEASURE(fk=tan(j+fi), loop_n);
}结果：
platform_function_time_measure (n=100)
opratetime(us)time avg(ns)
k=(i>j)?i:j337 336 336 336 33633
rand()3763 3753 3756 3752 3756375
fk=sqrt(j+fi)58442 58416 58417 58419 584165842
fk=sin(j+fi)111011 110967 110970 110967 11097111097开方没有想象中的耗时，三角函数耗时真的大。如果对精度要求不高，如呼吸灯什么的，强烈建议使用快速三角函数。
malloc时间消耗
#define ALLOC_TIME_MEASURE(OP, n) \
do { \
printf("%s%c\t", #OP, strlen(#OP)<8?'\t':' ');
\
int64_t timesum = 0;
\
int64_t start = esp_timer_get_time();
\
for(int i=1;
i<=n;
i++) { \
OP;
\
} \
int64_t t = esp_timer_get_time() - start;
\
printf("%lld ", t);
\
timesum += t;
\
printf("\t\t%lld\n", 1000*timesum / (n));
\
} while (0)#define ALLOC_FREE_MEASURE(OP, n) \
do { \
printf("%s%c\t\t", #OP, strlen(#OP)<8?'\t':' ');
\
int64_t timesum = 0;
\
int64_t start = esp_timer_get_time();
\
for(int i=1;
i<=n;
i++) { \
OP;
\
} \
int64_t t = esp_timer_get_time() - start;
\
printf("%lld ", t);
\
timesum += t;
\
printf("\t\t%lld\n", 1000*timesum / (n));
\
} while (0)void platform_alloc_time_measure(void)
{
int loop_n = 100;
printf("\nplatform_alloc_time_measure (n=%d)\n", loop_n);
printf("oprate\t\t\ttime(us)\ttime avg(ns)\n");
volatile int* k[loop_n+1];
ALLOC_TIME_MEASURE(k[i]=malloc(16), loop_n);
ALLOC_FREE_MEASURE(free(k[i]), loop_n);
ALLOC_TIME_MEASURE(k[i]=malloc(100), loop_n);
ALLOC_FREE_MEASURE(free(k[i]), loop_n);
ALLOC_TIME_MEASURE(k[i]=malloc(2000), loop_n);
ALLOC_FREE_MEASURE(free(k[i]), loop_n);
}结果：
platform_alloc_time_measure (n=100)
opratetime(us)time avg(ns)
k[i]=malloc(16)3173170
free(k[i])1951950
k[i]=malloc(100)3173170
free(k[i])1941940
k[i]=malloc(2000)6136130
free(k[i])1891890free耗时比较稳定。malloc耗时会随着空间增大而增大，但也不是线性关系。并且这两个的耗时也不能忽略不计。
End
【嵌入式项目中打造自己的utils库-不同芯片的基础时空开销计算】通过这些对比，以前忽视的malloc和free，其实也是时间空间消耗大户。求余运算与运算也值得注意。
有了这些空间和时间消耗的对比，相信大家就可以对自己使用的平台有了更进一步的了解。同时在以后需要优化代码的时候，也能有一个明确的方向。
