14.5.3 内存约束与静态分配
所属:全栈开发面试题库 / 14 物联网与嵌入式软件 / 14.5 低功耗与资源约束
本节要解决的问题
MCU 动辄只有 20KB RAM、256KB Flash,一个 TLS 握手就要 20KB,怎么分配?多数人上来就用 malloc,结果碎片、不确定的分配时间、栈溢出一起爆。本节解决四个具体问题:一是建立 RAM/Flash 预算表,从芯片选型阶段就知道够不够;二是讲清为什么硬实时与安全相关项目禁用堆,改用静态分配与内存池;三是说清内存池(固定块分配器)的原理与碎片问题;四是给出栈与堆的划分依据、链接脚本怎么写、MPU 怎么保护。
学习目标
学完本节,你应当能够:
- 列出 RAM 的每一部分(栈、堆、全局变量、内存池、外设寄存器)并算总量。
- 解释为什么 malloc 在实时系统里有问题,以及内存池如何替代。
- 设计一个固定块大小的内存池,说明内部碎片与外部碎片的区别。
- 写出链接脚本里 RAM/Flash 布局,以及如何用 MPU 保护栈与关键数据。
先修与前置
- 建议先读 14.1.4 任务划分、优先级与栈设计,理解栈深估算。
- 本节与 14.5.4 算力约束与算法裁剪 配合看:内存预算决定能用多复杂的算法。
知识地图
RAM 预算表(示例:64KB RAM):
.data/.bss : 全局变量 ~8 KB
主栈 (MSP) : 启动 + ISR ~1 KB
任务栈集合 : 每个任务独立 ~20 KB(5 个任务 × 4KB)
内存池 : 协议缓冲 ~16 KB
外设 DMA 缓冲 : 环形缓冲 ~8 KB
预留 : MPU 保护区 ~4 KB
------------------------------------
合计 ~57 KB / 64 KB
分配策略:
静态分配(编译期确定):全局数组、静态任务栈、内存池预分配
动态分配(运行期):malloc(不推荐)、固定块内存池(推荐)
核心术语
- .data/.bss:已初始化全局变量(.data)与零初始化全局变量(.bss),启动时从 Flash 加载/清零。
- 栈(Stack):函数调用栈,MSP 用于启动与中断,PSP 用于任务。
- 堆(Heap):malloc 管理的区域,实时系统通常禁用。
- 内存池(Memory Pool):预先分配固定大小块的分配器,O(1) 分配释放,无碎片。
- 外部碎片:堆里空闲块分散,没有一块连续足够大,但总空闲够。
- 内部碎片:分配的块比实际需求大,浪费的部分。
- 链接脚本(Linker Script):指定段、栈、堆在 Flash/RAM 中的位置。
- MPU:内存保护单元,划分区域权限,栈溢出触发异常。
- XIP(Execute in Place):代码直接在 Flash 上执行,不复制到 RAM。
覆盖范围
- RAM/Flash 预算表与计算
- 静态分配 vs 动态分配的取舍
- 内存池原理、固定块大小与碎片
- 栈深估算与栈保护
- 链接脚本内存布局
- MPU 区域配置与栈溢出检测
- Flash 占用分析与优化
高频题速览
| 编号 | 题目 | 难度 | 频率 |
|---|---|---|---|
| 14.5.3-001 | 为什么嵌入式系统要避免 malloc? | 基础 | ★★★★★ |
| 14.5.3-002 | RAM 预算表怎么列?每部分占多少? | 基础 | ★★★★ |
| 14.5.3-003 | 内存池是什么?为什么比 malloc 好? | 基础 | ★★★★★ |
| 14.5.3-004 | 外部碎片和内部碎片怎么区分? | 进阶 | ★★★★ |
| 14.5.3-005 | 栈深怎么估算?栈溢出怎么发现? | 进阶 | ★★★★ |
| 14.5.3-006 | 链接脚本里栈和堆怎么安排? | 进阶 | ★★★ |
| 14.5.3-007 | Flash 占用怎么分析?哪些段占空间? | 进阶 | ★★★ |
| 14.5.3-008 | MPU 怎么保护栈与关键数据? | 高级 | ★★★ |
| 14.5.3-009 | XIP 与复制到 RAM 执行的取舍? | 高级 | ★★★ |
| 14.5.3-010 | TLS 协议栈在 64KB RAM 设备上怎么跑? | 高级 | ★★★ |
14.5.3-001 为什么嵌入式系统要避免 malloc?
一句话结论
malloc 有三个硬伤:分配时间不确定(可能遍历空闲链表或合并碎片)、内存碎片化(长期运行后分配失败)、以及在中断上下文里不能用;硬实时与安全相关项目要求所有内存分配在编译期确定,因此用静态数组与内存池替代。
概念解释
- 不确定时间:malloc 可能很快(O(1) 空闲块),也可能很慢(遍历合并碎片),无法做 WCET 分析。
- 碎片化:长期 malloc/free 后空闲块分散,即使总空闲够也分配不出大块。
- 中断安全:malloc 通常带全局锁,在 ISR 里会死锁或破坏堆状态。
- 替代:静态分配(编译期确定大小)+ 内存池(固定块 O(1) 分配)。
原理流程
- 分析需求:哪些 buffer 需要动态大小?多大?生命周期多长?
- 能用静态就静态:协议 buffer、任务栈、传感器缓存都预定义大小。
- 必须动态的用内存池:按块大小分池(如 64B/256B/1KB),预分配好。
- 禁用 malloc:链接脚本里不设堆,或
#define malloc pool_alloc替换。 - 验证:长时压测(72 小时)后内存池使用率与静态 buffer 水位。
代码或图示
/* 错误:运行时 malloc 协议 buffer */
void on_packet(uint8_t *data, size_t len) {
uint8_t *buf = malloc(len); /* 不确定时间,可能失败 */
parse(buf);
free(buf);
}
/* 正确:静态 buffer + 内存池 */
#define PROTO_BUF_SIZE 256
#define PROTO_POOL_CNT 8
static uint8_t proto_pool[PROTO_POOL_CNT][PROTO_BUF_SIZE];
static uint8_t proto_used[PROTO_POOL_CNT]; /* 位图 */
uint8_t *proto_alloc(void) {
for (int i = 0; i < PROTO_POOL_CNT; i++) {
if (!proto_used[i]) { proto_used[i] = 1; return proto_pool[i]; }
}
return NULL; /* 池满,显式失败,不阻塞 */
}
void proto_free(uint8_t *p) {
int idx = (p - &proto_pool[0][0]) / PROTO_BUF_SIZE;
proto_used[idx] = 0;
}
常见误区
- 误区:malloc 一次就够,长期运行没问题;正解:碎片化是长期问题,可能上线三个月后才出现。
- 误区:C++ 不能在嵌入式用;正解:可以用,但要禁用 new/delete 或用内存池重载。
- 误区:内存池一定比 malloc 省内存;正解:固定块有内部碎片(块大小大于需求),但无外部碎片。
追问
- 为什么 malloc 时间不确定?答:malloc 要在空闲链表找合适块,可能从最佳适配开始遍历,碎片多时遍历变长。机制上分配器的数据结构(空闲链表/树)决定查找复杂度。边界在于:tlsf 等实时分配器能做到 O(1),但仍有碎片风险。延伸:安全标准(如 IEC 61508)要求所有内存静态分配,不允许任何动态分配。
- 内存池怎么处理多种块大小?答:按大小分池——64B 池、256B 池、1KB 池,分配时选最小够的池。机制上多池设计让小请求不浪费大池。边界在于:分池太多会增加管理开销与内部碎片。延伸:常见做法是 3–4 档(64/256/1024/4096)。
- 内存池满了怎么办?答:显式失败(返回 NULL),由上层决定——丢包、用缓存、或报错重启。机制上内存池是固定大小,不能像 malloc 那样扩大。边界在于:池满是设计问题,要在压测中调大池或减少并发。延伸:RTOS 的
xQueueSend满时丢弃而不是阻塞,与内存池满的处理一致。
14.5.3-002 RAM 预算表怎么列?每部分占多少?
一句话结论
RAM 预算表 = .data/.bss(全局变量)+ 主栈(启动/ISR)+ 任务栈集合 + 内存池 + DMA/外设缓冲 + 预留/MPU 保护区;总量必须小于芯片 RAM,且留 20% 余量。
概念解释
- .data:已初始化全局变量,启动时从 Flash 复制到 RAM。
- .bss:零初始化全局变量,启动时清零。
- 主栈(MSP):启动代码与中断用,常见 1–2KB。
- 任务栈:每个 RTOS 任务独立栈,按栈深估算。
- 内存池:协议 buffer、消息队列预分配。
原理流程
- 列全局变量:编译后用 map 文件看 .data/.bss 大小。
- 估算任务栈:按 14.1.4 的栈深估算方法,每个任务给 1.2–1.5 倍余量。
- 列内存池:协议 buffer 数量与大小、消息队列长度。
- 列 DMA 缓冲:UART/SPI/ADC 环形缓冲、屏幕 framebuffer。
- 加预留:MPU 保护区、未来扩展、异常栈。
- 求和,与芯片 RAM 对比,留 20% 余量。
代码或图示
RAM 预算表示例(64KB RAM 芯片):
项目 大小 说明
.data/.bss 8 KB 全局变量(map 文件)
主栈 MSP 1 KB 启动 + ISR
任务栈 ×5 20 KB 4KB × 5(含 1.5 倍余量)
协议内存池 16 KB 256B × 8 + 1KB × 8
消息队列 4 KB 4 个队列 × 1KB
UART DMA 缓冲 4 KB 2KB × 2(RX/TX)
ADC 缓冲 2 KB 1KB 环形
MPU 保护区 2 KB 栈溢出检测
预留 7 KB 10% 余量
------------------------------------------
合计 64 KB 刚好 100%(危险)
调整:协议池减到 12KB → 60KB,留 4KB 余量
常见误区
- 误区:只看全局变量大小;正解:任务栈与内存池通常占 RAM 一半以上。
- 误区:用编译时的 .bss 大小就算完;正解:运行时栈水位可能比静态估算大 50%。
- 误区:不留余量;正解:后续加功能会吃 RAM,20% 余量是必要的。
追问
- map 文件怎么看?答:链接后生成 .map 文件,里面列出 .data/.bss/.text 段大小与各符号地址。机制上链接脚本决定段位置,map 是最终布局报告。边界在于:map 文件是编译期布局,运行时栈水位要单独测。延伸:用
arm-none-eabi-nm --size-sort或 IDE 图形工具看大符号。 - 任务栈大小怎么定?答:按最深调用链估算 + 中断嵌套 + 库开销,再乘 1.5 倍余量,运行时用栈水位验证。机制上栈深是 WCET 分析的一部分。边界在于:栈水位只能测到观测最大值,未触发路径要靠静态分析补。延伸:把栈大小做成编译期常量,CI 里回归检查。
- DMA 缓冲为什么要单独列?答:DMA 缓冲必须在 RAM 里且对齐,不能放栈上(可能被回收),且要考虑缓存一致性。机制上 DMA 直接读写内存,地址要稳定。边界在于:Cortex-M7 带 D-cache 时,DMA 缓冲要放非缓存区或手动清理。延伸:低功耗 MCU 通常无缓存,简单些。
14.5.3-003 内存池是什么?为什么比 malloc 好?
一句话结论
内存池是编译期预分配一组固定大小块,分配时从空闲链表取一块(O(1)),释放时归还(O(1));它没有外部碎片,时间确定,可在中断安全的上下文中用(无锁单生产者版本)。
概念解释
- 空闲链表:预分配的块串成链表,分配时取头,释放时挂回。
- 固定块大小:所有块一样大,分配时不用找最合适的块。
- 内部碎片:块大小 256B 但只用 100B,浪费 156B。
- 多池:按块大小分多个池,减少内部碎片。
原理流程
- 编译期预分配:在静态数组里划 N 个固定大小块。
- 初始化:把所有块串成空闲链表。
- 分配:从空闲链表取下一块,返回指针,O(1)。
- 释放:把块挂回空闲链表,O(1)。
- 满了:返回 NULL,上层决定丢包或缓存。
- 多池:64B/256B/1KB 三个池,按需求选最小够的。
代码或图示
#define BLOCK_SIZE 256
#define BLOCK_COUNT 8
typedef struct block {
struct block *next;
uint8_t data[BLOCK_SIZE - sizeof(struct block*)];
} block_t;
static block_t pool_storage[BLOCK_COUNT];
static block_t *free_list;
void pool_init(void) {
free_list = &pool_storage[0];
for (int i = 0; i < BLOCK_COUNT - 1; i++) {
pool_storage[i].next = &pool_storage[i + 1];
}
pool_storage[BLOCK_COUNT - 1].next = NULL;
}
void *pool_alloc(void) {
if (!free_list) return NULL;
block_t *b = free_list;
free_list = free_list->next;
return b->data;
}
void pool_free(void *p) {
if (!p) return;
block_t *b = (block_t *)((uint8_t *)p - sizeof(struct block*));
b->next = free_list;
free_list = b;
}
常见误区
- 误区:内存池完全无碎片;正解:外部碎片没有,但内部碎片(块大小大于需求)存在。
- 误区:所有块一样大最优;正解:多池设计(不同大小)减少内部碎片。
- 误区:内存池线程安全;正解:单池版本在多任务并发时要加锁,单生产者单消费者可无锁。
追问
- 内存池怎么线程安全?答:分配释放操作包在临界区里(关中断或互斥量),或用单生产者单消费者无锁队列。机制上空闲链表是共享数据,并发修改会破坏链表。边界在于:临界区不能太长,否则影响实时性。延伸:RTOS 提供的内存池(如 FreeRTOS
xPortGetFreeHeapSize、Zephyr k_mem_slab)是线程安全的。 - 多池怎么选块大小?答:按实际需求分布——统计协议 buffer 大小分布,选覆盖 90% 需求的块大小。机制上分池太多会增加管理开销。边界在于:无法预估时用 64/256/1024 三档起步,压测后调整。延伸:池满时可以从大池"借"一块给小请求(浪费但不失败)。
- 内存池能在 ISR 里用吗?答:单生产者单消费者版本(ISR 生产、任务消费)可以无锁分配。机制上 ISR 只往空闲链表取一块,任务侧只归还,两者不竞争。边界在于:多生产者(多个 ISR 或任务)必须加锁,而 ISR 里不能加锁。延伸:ISR 侧用预分配的 SPSC 队列更安全。
14.5.3-004 外部碎片和内部碎片怎么区分?
一句话结论
外部碎片是堆里空闲块分散,没有一块连续足够大(总空闲够但分不出);内部碎片是分配的块比实际需求大,浪费的部分;内存池没有外部碎片但有内部碎片,malloc 两者都有。
概念解释
- 外部碎片:空闲空间被已分配块切成小段,无法满足大块请求。
- 内部碎片:分配器按最小块大小对齐,请求 100B 给 128B,浪费 28B。
- 紧凑(Compaction):移动已分配块把空闲合并,但嵌入式不支持(指针会失效)。
- 内存池:固定块消除外部碎片,但内部碎片取决于块大小设计。
原理流程
- malloc 场景:分配 100B、200B、300B,释放中间 200B,空闲 200B 但要 400B 时失败。
- 内存池场景:所有块 256B,分配 100B 用一块,内部碎片 156B,但没有外部碎片。
- 多池优化:64B 池给小请求,256B 池给中请求,1KB 池给大请求,减少内部碎片。
- 长期运行:内存池使用率稳定,malloc 可能越用越碎。
- 验证:压测 72 小时后,内存池成功分配率应接近 100%,malloc 可能下降。
代码或图示
外部碎片(malloc):
已分配: [100B][200B][300B]
释放中间 200B:
已分配: [100B] [300B]
空闲: [200B]
要 250B → 失败(虽然总空闲 200B,不够;且不连续)
内部碎片(内存池):
块大小 256B,请求 100B
分配: [256B 块,只用 100B]
浪费: 156B(内部碎片)
但下次请求 200B 也能从另一块取,不依赖连续性
多池:
64B 池 → 请求 50B,浪费 14B
256B 池 → 请求 200B,浪费 56B
1KB 池 → 请求 800B,浪费 200B
常见误区
- 误区:内存池无碎片;正解:内部碎片仍存在,只是没有外部碎片。
- 误区:碎片可以通过紧凑解决;正解:嵌入式系统不支持紧凑(指针固定),只能预防。
- 误区:块大小选大减少碎片;正解:块越大内部碎片越大,要按需求分布选。
追问
- 为什么嵌入式不能紧凑?答:紧凑要移动已分配块,但外部持有指针,移动后指针失效。机制上 C/C++ 不支持 GC 式移动。边界在于:Java/Go 有 GC 可以移动,但嵌入式 C 没有。延伸:这也是为什么嵌入式用内存池而不是 malloc 的根本原因。
- 内部碎片怎么最小化?答:统计实际请求大小分布,选块大小覆盖大多数请求。机制上多池设计让小请求用小块。边界在于:无法预估所有请求时,留一个大池做兜底。延伸:压测时记录每个池的使用率与请求大小,迭代调整。
- malloc 有没有实时安全的版本?答:TLSF(Two-Level Segregated Fit)等实时分配器能做到 O(1) 分配,且碎片较少。机制上用多级空闲链表按大小分类。边界在于:即使 O(1),长期碎片仍存在,且 ISR 里仍不能用。延伸:安全认证项目仍倾向完全静态分配,不依赖任何动态分配器。
14.5.3-005 栈深怎么估算?栈溢出怎么发现?
一句话结论
栈深 = 最深调用链栈帧 + 中断嵌套开销 + 上下文保存 + 库开销 + 安全余量;发现手段是栈填充魔术字 + 运行时水位(high water mark)+ MPU 保护区。
概念解释
- 栈帧:函数调用保存的返回地址、参数、局部变量、寄存器。
- 栈水位:运行以来栈使用的最低地址,即剩余最小余量。
- 栈填充:创建任务时把栈写成魔术字,运行后扫描未动区域。
- MPU 保护区:栈底设不可访问,溢出触发 MemManage 异常。
原理流程
- 静态估算:找最深调用链(含库函数 printf、snprintf、加密库)。
- 加中断嵌套:Cortex-M 异常入栈 8 寄存器(32B),加软件保存剩余寄存器。
- 加库开销:printf/snprintf 可能几百 B 到数 KB,单独测。
- 运行时验证:开栈填充,压测后读水位。
- 最终栈深 = 实测最坏值 × 1.2–1.5,CI 回归。
代码或图示
/* FreeRTOS:创建任务后查询栈水位 */
xTaskCreate(sensor_task, "sensor", 512, NULL, 5, &h);
/* 压测后 */
UBaseType_t hw = uxTaskGetStackHighWaterMark(h); /* 单位 word */
/* hw 越小说明越接近溢出 */
/* 栈溢出钩子 */
void vApplicationStackOverflowHook(TaskHandle_t t, char *name) {
log_crash("stack overflow: %s", name);
NVIC_SystemReset();
}
栈深估算示例(Cortex-M4,无 FPU):
最深调用链: main → parse → json → snprintf ≈ 180B
中断入栈: 8 regs × 4 = 32B
软件保存: ~40B
snprintf 缓冲: 实测 ~200B
合计: ~450B → 取 640B(1.5 倍余量)
常见误区
- 误区:任务跑起来没崩就够;正解:栈溢出破坏别的任务数据,随机死机,必须压测。
- 误区:所有任务给同样大栈;正解:栈需求差异大,统一大栈浪费 RAM。
- 误区:只看自己代码;正解:printf/TLS/加密是栈消耗大户,要单独测。
追问
- MPU 栈保护有什么代价?答:要配置 MPU 区域,每次切换可能重配,溢出时触发异常而不是静默。机制上 MPU 把栈底若干字节设 no-access。边界在于:MPU 区域数量有限(常见 8 个),多任务时无法给每个任务单独区域。延伸:安全认证项目普遍要求硬件级栈保护。
- 中断用哪个栈?答:Cortex-M 中断默认用 MSP(主栈),任务用 PSP。机制上 CONTROL 寄存器决定当前栈指针,异常进入自动切 MSP。边界在于:ISR 里调 RTOS API 时内核仍用任务栈保存上下文,两套栈都要留余量。延伸:FreeRTOS 可配中断专用栈,隔离最坏用量。
- 为什么 printf 栈消耗大?答:printf 内部有格式化缓冲、可变参数处理、浮点转换,实现复杂。机制上 newlib-nano 的 printf 比 full newlib 小,但仍有几百 B。边界在于:嵌入式项目常改用轻量日志(微格式化、不带浮点)减少栈。延伸:用 RTT/ITM 输出代替 printf,既省栈又省时间。
14.5.3-006 链接脚本里栈和堆怎么安排?
一句话结论
链接脚本定义 Flash 段(.text/.rodata)与 RAM 段(.data/.bss/栈/堆),栈从 RAM 顶部向下增长,堆从 .bss 顶部向上增长;禁用堆时堆大小设为 0,栈大小显式定义。
概念解释
- .text:代码段,在 Flash。
- .rodata:只读数据(常量、字符串),在 Flash。
- .data:已初始化全局变量,加载时从 Flash 复制到 RAM。
- .bss:零初始化全局变量,启动时清零。
- 栈:RAM 顶部,向下增长,MSP 初始化为 RAM 顶端。
- 堆:.bss 之后向上增长,禁用时设为 0。
原理流程
- 定义 Flash 与 RAM 地址:芯片数据手册给起止地址。
- .text/.rodata 放 Flash,.data/.bss/栈/堆放 RAM。
- 栈顶 = RAM 顶端,栈大小在脚本里定义(如 0x400)。
- 堆大小:用内存池时设为 0,或保留小堆(如 0x200)给 C 库内部用。
- 启动代码:复制 .data、清零 .bss、设 MSP 为栈顶。
代码或图示
/* GCC 链接脚本(简化) */
MEMORY
{
FLASH (rx) : ORIGIN = 0x08000000, LENGTH = 256K
RAM (rwx) : ORIGIN = 0x20000000, LENGTH = 64K
}
_estack = ORIGIN(RAM) + LENGTH(RAM); /* 栈顶 = RAM 末端 */
_Min_Stack_Size = 0x400; /* 1KB 主栈 */
_Min_Heap_Size = 0x0; /* 禁用堆 */
SECTIONS
{
.text : { *(.text*) *(.rodata*) } > FLASH
_etext = .;
.data : {
_sdata = .;
*(.data*)
_edata = .;
} > RAM AT > FLASH
.bss : {
_sbss = .;
*(.bss*)
*(COMMON)
_ebss = .;
} > RAM
/* 栈与堆在 RAM 顶部,由启动代码与链接符号处理 */
}
常见误区
- 误区:堆大小随便设;正解:用内存池时设 0,否则链接器不报错但运行时 malloc 失败。
- 误区:栈大小在 C 代码里设;正解:栈顶在链接脚本定义,启动代码设 MSP。
- 误区:.bss 不用初始化;正解:启动代码必须清零 .bss,否则全局变量随机值。
追问
- 启动代码做什么?答:复制 .data 从 Flash 到 RAM、清零 .bss、设 MSP 为栈顶、调 main()。机制上这些是 C 运行时初始化。边界在于:C++ 还要调全局构造函数。延伸:嵌入式常精简启动代码,不用 newlib 的复杂初始化。
- 怎么知道 RAM 用了多少?答:看 map 文件,或在链接脚本里算
_ebss到栈顶的距离。机制上 map 文件列出所有段地址与大小。边界在于:栈与堆是动态使用,编译期只知道上限。延伸:用arm-none-eabi-size看 .text/.data/.bss 大小。 - 为什么禁用堆还要设 _Min_Heap_Size?答:某些 C 库函数(如 strtol、malloc)即使你不调,内部可能引用堆符号,链接器需要符号存在。机制上设为 0 但符号保留。边界在于:完全不用 malloc 时可以设 0,需要小堆(如 C 库内部)设 0x200。延伸:用 newlib-nano 时堆需求更小。
14.5.3-007 Flash 占用怎么分析?哪些段占空间?
一句话结论
Flash 占用 = .text(代码)+ .rodata(常量/字符串)+ .data 初始化值 + 中断向量表;最大头通常是 .text(库函数),其次是字符串表与 TLS/证书等大常量。
概念解释
- .text:所有代码,包括编译器内联、库函数。
- .rodata:常量、字符串字面量、查找表。
- .data 初始化值:.data 段在 Flash 的初始镜像。
- 中断向量表:起始处的异常向量,常见 0x200–0x400。
原理流程
- 编译后用 size 命令看 .text/.rodata/.data 大小。
- 用 map 文件找大符号:哪个函数占最多?
- 库函数审查:printf/float 格式化/TLS 栈是大头。
- 优化:-Os 优化体积、去掉不用的库、用轻量替代。
- 验证:每次加功能后看 Flash 增量,CI 回归。
代码或图示
Flash 占用示例(256KB Flash):
段 大小 说明
中断向量表 0x200 512B
.text 120KB 代码
.rodata 30KB 常量/字符串/证书
.data 初始值 4KB 已初始化全局变量
------------------------------------------
合计 ~155KB / 256KB
大符号分析:
printf/float 格式化: ~8KB
TLS 栈(mbedTLS): ~40KB
证书/根 CA: ~6KB
用户代码: ~60KB
优化:
-Os: 体积减 10–20%
-ffunction-sections + --gc-sections: 去掉不用函数
轻量 TLS(如 TinyDTLS): 减 20KB
常见误区
- 误区:代码体积小就够;正解:.rodata 里的证书、字符串、查找表常占大头。
- 误区:-O2 比 -Os 好;正解:体积优先用 -Os,速度优先才用 -O2。
- 误区:链接器自动去掉不用代码;正解:要开 -ffunction-sections + --gc-sections 才去掉。
追问
- 怎么去掉不用的库函数?答:编译时加 -ffunction-sections,链接时加 --gc-sections,把每个函数放独立段,未引用的段被丢弃。机制上链接器从入口(main/复位向量)开始遍历引用,未引用的段回收。边界在于:构造函数、中断向量、被函数指针引用的函数不能简单 gc。延伸:map 文件里看哪些段被保留了。
- TLS 栈为什么占 Flash?答:TLS 实现(mbedTLS 等)包含加密算法实现(RSA、ECC、AES、SHA)、证书解析、握手状态机,代码量几十 KB。机制上加密算法是数学密集型代码。边界在于:低功耗 MCU 通常用轻量 TLS(TinyDTLS、Mbed TLS 精简配置)。延伸:选芯片时要考虑是否有硬件加密加速器,能减代码量。
- 字符串表怎么优化?答:用枚举 ID 代替字符串,或压缩字符串表。机制上字符串字面量在 .rodata,占 Flash。边界在于:日志字符串在 release 版可以去掉(只留 ID)。延伸:用 printf 宏在编译期裁剪日志级别。
14.5.3-008 MPU 怎么保护栈与关键数据?
一句话结论
MPU 把 RAM 划成若干区域,设权限(可读/可写/可执行/不可访问);栈底设为不可访问,溢出立即触发 MemManage 异常,而不是静默破坏别的任务数据。
概念解释
- MPU:内存保护单元,Cortex-M3/M4/M7 可选。
- 区域:常见 8 个区域,每个 32B 对齐。
- 权限:只读、读写、不可访问、可执行。
- MemManage 异常:访问违规时触发,可在异常里记录现场。
原理流程
- 划分 RAM:代码区、只读数据区、栈保护区、外设区。
- 栈保护区:在每个任务栈底设 32B–128B 不可访问。
- 切换任务时:重配 MPU 区域指向当前任务栈。
- 溢出时:触发 MemManage 异常,记录 LR/PC/栈指针。
- 关键数据:根证书、固件元数据设为只读,防止误写。
代码或图示
/* MPU 区域配置(Cortex-M4) */
void mpu_config_stack(uint32_t stack_base, uint32_t stack_size) {
/* 栈底保护区:stack_base 开始的 32B 不可访问 */
MPU->RNR = 0;
MPU->RBAR = stack_base & MPU_RBAR_ADDR_Msk;
MPU->RASR = (0x03 << MPU_RASR_SIZE_Pos) /* 32B */
| (0 << MPU_RASR_AP_Pos) /* 不可访问 */
| MPU_RASR_ENABLE_Msk;
}
/* MemManage 异常 */
void MemManage_Handler(void) {
uint32_t *cfsr = &SCB->CFSR;
log_crash("MemManage: CFSR=0x%x", *cfsr);
/* 记录现场,复位或安全停机 */
}
常见误区
- 误区:MPU 自动保护所有任务;正解:MPU 区域数量有限,要手动配,切换任务时重配。
- 误区:栈填充魔术字够了;正解:魔术字是软件检查,MPU 是硬件保护,更可靠。
- 误区:MPU 只保护栈;正解:还能保护关键数据(证书、固件元数据)不被误写。
追问
- MPU 区域数量有限怎么办?答:8 个区域通常够——代码、只读数据、栈保护、外设、RAM 默认、再加几个子区域。机制上 MPU 支持子区域(sub-region)把一个大区分成 8 小块。边界在于:多任务时无法给每个任务单独区域,通常只保护当前运行任务的栈。延伸:安全认证项目用 MPU 做任务隔离,每个任务有独立区域。
- MemManage 异常里能做什么?答:记录故障现场(CFSR、PC、LR、栈指针),通过备用串口或 RTT 输出,然后复位。机制上异常处理要短,不能做复杂操作。边界在于:异常时 RAM 可能已被破坏,记录要小心。延伸:把关键故障信息存备份寄存器,复位后回传。
- MPU 影响性能吗?答:极小,每次切换任务重配几个寄存器,约几十周期。机制上 MPU 检查在总线访问时做,无额外开销。边界在于:频繁重配 MPU 的任务切换有开销,但远小于实时性收益。延伸:低频率切换任务不受影响。
14.5.3-009 XIP 与复制到 RAM 执行的取舍?
一句话结论
XIP(直接在 Flash 上执行)省 RAM 但取指慢(Flash 等待周期),复制到 RAM 执行快但占 RAM;低功耗 MCU 通常 XIP + 少量 RAM 执行段(如关键算法),高性能 MCU 才需要大规模 RAM 执行。
概念解释
- XIP:代码在 Flash 上,CPU 取指直接从 Flash 读。
- Flash 等待周期:Flash 访问比 RAM 慢,高频时要插等待周期。
- RAM 执行:把关键代码段复制到 RAM,取指快。
- 指令缓存(I-Cache):M7 等带缓存,减少 XIP 等待。
原理流程
- 默认 XIP:所有代码在 Flash,简单且省 RAM。
- 高频时 Flash 等待周期增加:如 48MHz 时 2 个等待周期。
- 关键代码复制到 RAM:如加密、Flash 擦写、中断密集段。
- 链接脚本:把 .ramfunc 段放 RAM,启动时从 Flash 复制。
- 取舍:RAM 紧张就全 XIP,RAM 充足且性能敏感才 RAM 执行。
代码或图示
/* 链接脚本:.ramfunc 段在 RAM 执行,Flash 存初始镜像 */
.ramfunc : {
_sramfunc = .;
*(.ramfunc)
_eramfunc = .;
} > RAM AT > FLASH
/* 启动代码复制 .ramfunc 到 RAM */
extern uint32_t _sramfunc, _eramfunc, _siramfunc;
void copy_ramfunc(void) {
uint32_t *src = &_siramfunc;
uint32_t *dst = &_sramfunc;
while (dst < &_eramfunc) *dst++ = *src++;
}
/* 函数属性:放到 RAM 执行 */
__attribute__((section(".ramfunc")))
void fast_crypto(void) { ... }
常见误区
- 误区:XIP 一定慢;正解:带 I-Cache 的 M7 XIP 性能接近 RAM。
- 误区:所有代码都该 RAM 执行;正解:RAM 宝贵,只放性能关键段。
- 误区:RAM 执行不耗 Flash;正解:Flash 仍存初始镜像,只是运行时在 RAM。
追问
- Flash 等待周期怎么决定?答:芯片数据手册给频率-等待周期表,如 24MHz 时 0 等待,48MHz 时 1 等待,80MHz 时 2 等待。机制上 Flash 访问有固定延迟,CPU 频率越高越要插周期。边界在于:高频时 XIP 性能下降,RAM 执行或 I-Cache 能缓解。延伸:低功耗 MCU 常用内部 Flash 加速(预取缓冲)减少等待。
- 哪些代码该放 RAM?答:Flash 擦写时不能从 Flash 取指(因为 Flash 正被擦)、加密算法(性能敏感)、中断密集段。机制上 Flash 擦写时总线被占用,取指暂停。边界在于:RAM 段不能太大,否则占 RAM 预算。延伸:把 Flash 驱动本身放 RAM 执行,这是常见做法。
- I-Cache 怎么缓解 XIP?答:I-Cache 缓存最近取指,循环代码重复命中缓存,不每次访问 Flash。机制上缓存命中率高时,有效等待周期接近 RAM。边界在于:M0+/M3 无 I-Cache,XIP 性能完全取决于 Flash 速度。延伸:选芯片时看是否有 I-Cache 与预取缓冲。
14.5.3-010 TLS 协议栈在 64KB RAM 设备上怎么跑?
一句话结论
TLS 握手要 20–40KB RAM(证书、握手消息、密钥上下文),64KB 设备必须用精简 TLS(TinyDTLS/Mbed TLS 配置裁剪)、静态分配上下文、最小密码套件、会话复用,且只在连接时才加载,平时释放。
概念解释
- TLS 握手:客户端 Hello、服务器 Hello、证书交换、密钥交换,需要缓冲多条消息。
- 证书链:服务器证书 + 中间 CA,解析时占用 RAM。
- 密码套件:选最小的(ECDHE-ECDSA-AES128-GCM),不用 RSA 大整数。
- 会话复用:session resumption 减少握手开销与 RAM。
原理流程
- 选精简 TLS:Mbed TLS 关闭不用的算法、裁剪证书链、静态配置。
- 静态分配上下文:TLS context 编译期分配,不 malloc。
- 最小密码套件:只开 ECDHE-ECDSA-AES128-GCM-SHA256。
- 连接时加载:握手阶段才占用大缓冲,握手完成后释放到小状态。
- 会话复用:重连用 session ticket,不重新握手。
代码或图示
TLS RAM 预算(64KB 设备,精简 Mbed TLS):
项目 大小
TLS 上下文 2–4 KB(静态)
握手缓冲 2–4 KB(连接时分配)
证书解析 1–2 KB(最小证书链)
密钥上下文 1 KB
------------------------------------
握手峰值 6–10 KB
连接后稳定 2–3 KB
配置裁剪:
MBEDTLS_NO_PLATFORM_ENTROPY: 用硬件随机
MBEDTLS_SSL_MAX_CONTENT_LEN: 限制 MSS 到 1024
只开 ECP 25519/secp256r1,不开 RSA
关闭证书链验证(只验指纹)或最小链
常见误区
- 误区:TLS 随便链接就能跑;正解:默认 Mbed TLS 配置要 40KB+ RAM,必须裁剪。
- 误区:证书越大越安全;正解:最小证书链(ECDSA 256 约 1KB)比 RSA 2048(约 1.5KB)省。
- 误区:每次连接都握手;正解:session resumption 能省 50%+ RAM 与时间。
追问
- 怎么最小化 TLS RAM?答:限制 MSS(
MBEDTLS_SSL_MAX_CONTENT_LEN从 16KB 降到 1024)、只开必要密码套件、静态分配上下文、证书链只验叶子。机制上每个配置项对应一块缓冲。边界在于:MSS 太小会影响吞吐,要平衡。延伸:IoT 常用 DTLS(UDP),握手脚手架更小。 - 64KB 设备能跑 TLS 吗?答:能,但要裁剪到极致,且通常用 DTLS 而不是 TLS(UDP 握手脚手架小)。机制上 TLS 记录层 overhead 比 DTLS 大。边界在于:极低端设备(<16KB RAM)可能用预共享密钥(PSK)而不是证书,见 14.6.3。延伸:选芯片时看是否有硬件加密加速器,能减 RAM 与 Flash。
- 证书验证怎么省 RAM?答:只验叶子证书指纹(预存 SHA-256),不做完整证书链验证。机制上跳过 CA 链解析。边界在于:这牺牲了 PKI 的灵活性(证书轮换要更新设备指纹),但 IoT 设备常见。延伸:高安全场景仍要完整链验证,但用外部 SE(安全元件)存根证书。
动手练习
练习 1:给一个项目建 RAM 预算表
- 任务:选一个现成 RTOS 项目,从 map 文件提取 .data/.bss,列出任务栈、内存池、DMA 缓冲,算总 RAM 占用。
- 验收标准:
- 预算表覆盖所有 RAM 使用方。
- 总占用小于芯片 RAM 且留 20% 余量。
- 指出最大的 RAM 消耗者与优化空间。
练习 2:用内存池替换 malloc
- 任务:找一份用 malloc 的代码,改成固定块内存池,做压测 72 小时,对比分配成功率与内存使用。
- 验收标准:
- 内存池 O(1) 分配释放,无外部碎片。
- 压测后池使用率稳定。
- 计算内部碎片比例并说明优化方向。
自检清单
- [ ] 能否说出 malloc 在嵌入式的三个问题?
- [ ] 能否列出 RAM 预算表的每一项?
- [ ] 能否设计一个固定块内存池并解释碎片?
- [ ] 能否区分外部碎片与内部碎片?
- [ ] 能否给出栈深估算方法与三种溢出检测手段?
- [ ] 能否解释链接脚本里栈与堆的位置?
- [ ] 能否说出 Flash 占用的主要段与优化手段?
- [ ] 能否解释 MPU 如何保护栈与关键数据?
延伸阅读
- FreeRTOS 官方文档:Memory Management、Heap_1 到 Heap_5 实现、Static Allocation。
- Zephyr 文档:Memory Pools、
k_mem_slab、MPU 配置。 - ARM Cortex-M 权威指南:链接脚本、启动代码、MPU。
- Mbed TLS 配置文档:
mbedtls_config.h、裁剪 RAM 的选项。 - newlib-nano 文档:printf 体积与栈消耗。
待整理清单
- [ ] 补充 FreeRTOS Heap_1~5 的实现差异与适用场景
- [ ] 补充主流轻量 TLS(TinyDTLS、Mbed TLS 精简、wolfSSL)的 RAM/Flash 对比
- [ ] 补充 MPU 在 Cortex-M33/M55 上的新特性(SAU/IDAU)