罗罗编程学习记录 全栈面试题库
本页导航 展开查看

14.5.3 内存约束与静态分配

所属:全栈开发面试题库 / 14 物联网与嵌入式软件 / 14.5 低功耗与资源约束

本节要解决的问题

MCU 动辄只有 20KB RAM、256KB Flash,一个 TLS 握手就要 20KB,怎么分配?多数人上来就用 malloc,结果碎片、不确定的分配时间、栈溢出一起爆。本节解决四个具体问题:一是建立 RAM/Flash 预算表,从芯片选型阶段就知道够不够;二是讲清为什么硬实时与安全相关项目禁用堆,改用静态分配与内存池;三是说清内存池(固定块分配器)的原理与碎片问题;四是给出栈与堆的划分依据、链接脚本怎么写、MPU 怎么保护。

学习目标

学完本节,你应当能够:

  • 列出 RAM 的每一部分(栈、堆、全局变量、内存池、外设寄存器)并算总量。
  • 解释为什么 malloc 在实时系统里有问题,以及内存池如何替代。
  • 设计一个固定块大小的内存池,说明内部碎片与外部碎片的区别。
  • 写出链接脚本里 RAM/Flash 布局,以及如何用 MPU 保护栈与关键数据。

先修与前置

知识地图

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) 分配)。

原理流程

  1. 分析需求:哪些 buffer 需要动态大小?多大?生命周期多长?
  2. 能用静态就静态:协议 buffer、任务栈、传感器缓存都预定义大小。
  3. 必须动态的用内存池:按块大小分池(如 64B/256B/1KB),预分配好。
  4. 禁用 malloc:链接脚本里不设堆,或 #define malloc pool_alloc 替换。
  5. 验证:长时压测(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、消息队列预分配。

原理流程

  1. 列全局变量:编译后用 map 文件看 .data/.bss 大小。
  2. 估算任务栈:按 14.1.4 的栈深估算方法,每个任务给 1.2–1.5 倍余量。
  3. 列内存池:协议 buffer 数量与大小、消息队列长度。
  4. 列 DMA 缓冲:UART/SPI/ADC 环形缓冲、屏幕 framebuffer。
  5. 加预留:MPU 保护区、未来扩展、异常栈。
  6. 求和,与芯片 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。
  • 多池:按块大小分多个池,减少内部碎片。

原理流程

  1. 编译期预分配:在静态数组里划 N 个固定大小块。
  2. 初始化:把所有块串成空闲链表。
  3. 分配:从空闲链表取下一块,返回指针,O(1)。
  4. 释放:把块挂回空闲链表,O(1)。
  5. 满了:返回 NULL,上层决定丢包或缓存。
  6. 多池: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):移动已分配块把空闲合并,但嵌入式不支持(指针会失效)。
  • 内存池:固定块消除外部碎片,但内部碎片取决于块大小设计。

原理流程

  1. malloc 场景:分配 100B、200B、300B,释放中间 200B,空闲 200B 但要 400B 时失败。
  2. 内存池场景:所有块 256B,分配 100B 用一块,内部碎片 156B,但没有外部碎片。
  3. 多池优化:64B 池给小请求,256B 池给中请求,1KB 池给大请求,减少内部碎片。
  4. 长期运行:内存池使用率稳定,malloc 可能越用越碎。
  5. 验证:压测 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 异常。

原理流程

  1. 静态估算:找最深调用链(含库函数 printf、snprintf、加密库)。
  2. 加中断嵌套:Cortex-M 异常入栈 8 寄存器(32B),加软件保存剩余寄存器。
  3. 加库开销:printf/snprintf 可能几百 B 到数 KB,单独测。
  4. 运行时验证:开栈填充,压测后读水位。
  5. 最终栈深 = 实测最坏值 × 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。

原理流程

  1. 定义 Flash 与 RAM 地址:芯片数据手册给起止地址。
  2. .text/.rodata 放 Flash,.data/.bss/栈/堆放 RAM。
  3. 栈顶 = RAM 顶端,栈大小在脚本里定义(如 0x400)。
  4. 堆大小:用内存池时设为 0,或保留小堆(如 0x200)给 C 库内部用。
  5. 启动代码:复制 .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。

原理流程

  1. 编译后用 size 命令看 .text/.rodata/.data 大小。
  2. 用 map 文件找大符号:哪个函数占最多?
  3. 库函数审查:printf/float 格式化/TLS 栈是大头。
  4. 优化:-Os 优化体积、去掉不用的库、用轻量替代。
  5. 验证:每次加功能后看 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 异常:访问违规时触发,可在异常里记录现场。

原理流程

  1. 划分 RAM:代码区、只读数据区、栈保护区、外设区。
  2. 栈保护区:在每个任务栈底设 32B–128B 不可访问。
  3. 切换任务时:重配 MPU 区域指向当前任务栈。
  4. 溢出时:触发 MemManage 异常,记录 LR/PC/栈指针。
  5. 关键数据:根证书、固件元数据设为只读,防止误写。

代码或图示

/* 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 等待。

原理流程

  1. 默认 XIP:所有代码在 Flash,简单且省 RAM。
  2. 高频时 Flash 等待周期增加:如 48MHz 时 2 个等待周期。
  3. 关键代码复制到 RAM:如加密、Flash 擦写、中断密集段。
  4. 链接脚本:把 .ramfunc 段放 RAM,启动时从 Flash 复制。
  5. 取舍: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。

原理流程

  1. 选精简 TLS:Mbed TLS 关闭不用的算法、裁剪证书链、静态配置。
  2. 静态分配上下文:TLS context 编译期分配,不 malloc。
  3. 最小密码套件:只开 ECDHE-ECDSA-AES128-GCM-SHA256。
  4. 连接时加载:握手阶段才占用大缓冲,握手完成后释放到小状态。
  5. 会话复用:重连用 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 占用。
  • 验收标准:
    1. 预算表覆盖所有 RAM 使用方。
    2. 总占用小于芯片 RAM 且留 20% 余量。
    3. 指出最大的 RAM 消耗者与优化空间。

练习 2:用内存池替换 malloc

  • 任务:找一份用 malloc 的代码,改成固定块内存池,做压测 72 小时,对比分配成功率与内存使用。
  • 验收标准:
    1. 内存池 O(1) 分配释放,无外部碎片。
    2. 压测后池使用率稳定。
    3. 计算内部碎片比例并说明优化方向。

自检清单

  • [ ] 能否说出 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)