最近又重新翻看了《编程珠玑》这本书，里面着重对工程化处理进行了讲解，写得很好。印象最深的一个例子，作者拿布鲁克林大桥举例，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，并且互相拼接。
结果：
struct sizeof malloc size
int 4 16 267900 16 16 16 16 16 16 16 16
structc 1 16 16 16 16 16 16 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 20 20 20 20 20 524 20 20 20 20
structcd 16 20 20 20 20 20 20 20 20 20 20
structcdc 24 28 28 28 28 28 28 28 28 28 28
structiii 12 16 16 16 16 16 16 16 16 16 16
structiic 12 16 16 16 16 16 16 16 16 16 16
struct12 12 16 16 16 16 16 16 16 16 16 16
struct13 13 20 20 20 20 20 20 20 20 20 20
struct28 28 32 32 32 32 32 32 32 32 32 32
struct29 29 36 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)
oprate time(us) time avg(ns)
{} 1 1 1 1 1 0
k++ 11473 11475 11471 11471 11471 45
k=i+j 7306 7305 7301 7305 7305 29
k=i-j 7302 7305 7304 7305 7301 29
k=i*j 9390 9390 9390 9390 9390 37
k=i/j 9621 9620 9620 9621 9621 38
k=i%j 10664 10663 10662 10662 10662 42
k=i&j 8347 8346 8346 8346 8343 33
k=i|j 8347 8346 8347 8346 8346 33
//STM32F103C8
platform_int_time_measure (n=500)
oprate time(us) time avg(ns)
{} 27290 27290 27280 27280 27290 109
k++ 39150 39150 39150 39150 39150 156
k=i+j 39060 39060 39070 39070 39070 156
k=i-j 35110 35110 35110 35110 35100 140
k=i*j 35180 35180 35180 35180 35180 140
k=i/j 44410 44410 44410 44410 44410 177
k=i%j 63790 63790 63790 63790 63790 255
k=i&j 39060 39070 39070 39060 39060 156
k=i|j 46820 46820 46820 46820 46830 187ESP32的自增运算比较耗时，有点奇怪。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)
oprate time(us) time avg(ns)
{} 1685 1683 1683 1683 1683 168
fk=fi+fj 3941 3935 3939 3936 3935 393
fk=fi-fj 4516 4511 4514 4510 4514 451
fk=fi*fj 4293 4291 4295 4291 4295 429
fk=fi/fj 14036 14037 14034 14033 14037 1403
//STM32
platform_float_time_measure (n=100)
oprate time(us) time avg(ns)
{} 6000 6010 6000 6000 6010 600
fk=fi+fj 15670 15680 15680 15680 15680 1567
fk=fi-fj 14760 14760 14760 14760 14760 1476
fk=fi*fj 13920 13920 13920 13920 13920 1392
fk=fi/fj 20790 20790 20790 20790 20790 2079过程中需要先将整数赋值给浮点，消耗了不少时间。所以需要减去空运行的时间。即使是带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)
oprate time(us) time avg(ns)
k=i+j 7302 7304 7304 7301 7304 29
k=x[i]+j 7313 7313 7309 7312 7313 29
k=i+x[j] 10431 10429 10430 10430 10430 41
k=x[i]+x[j] 10432 10432 10432 10432 10432 41操作符和数学库时间消耗
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)
oprate time(us) time avg(ns)
k=(i>j)?i:j 337 336 336 336 336 33
rand() 3763 3753 3756 3752 3756 375
fk=sqrt(j+fi) 58442 58416 58417 58419 58416 5842
fk=sin(j+fi) 111011 110967 110970 110967 110971 11097开方没有想象中的耗时，三角函数耗时真的大。如果对精度要求不高，如呼吸灯什么的，强烈建议使用快速三角函数。
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)
oprate time(us) time avg(ns)
k[i]=malloc(16) 317 3170
free(k[i]) 195 1950
k[i]=malloc(100) 317 3170
free(k[i]) 194 1940
k[i]=malloc(2000) 613 6130
free(k[i]) 189 1890free耗时比较稳定。malloc耗时会随着空间增大而增大，但也不是线性关系。并且这两个的耗时也不能忽略不计。
End
通过这些对比，以前忽视的malloc和free，其实也是时间空间消耗大户。求余运算与运算也值得注意。
有了这些空间和时间消耗的对比，相信大家就可以对自己使用的平台有了更进一步的了解。同时在以后需要优化代码的时候，也能有一个明确的方向。