第1章：内存分配策略：静态分配、动态分配与内存池

各位做ADAS的同行，咱们今天聊聊内存分配。说实话，这话题看着基础，但我在实际项目中踩过的坑，十个手指头都数不过来。你想想看，ADAS系统里跑的是实时算法，一个内存泄漏可能就让车辆在高速上“失明”几毫秒——这后果谁担得起？

1.1 静态分配：最朴实的方案

静态分配，说白了就是在编译时就定好内存大小。我最早做ADAS项目时，团队里有个老工程师坚持“能用静态绝不用动态”。当时我还觉得他保守，后来才明白——在安全关键系统里，确定性比灵活性重要得多。

举个例子，摄像头采集的帧缓冲区，我习惯用静态数组。为什么？因为帧大小是固定的——比如1920x1080的YUV图像，每个像素2字节，那就是1920*1080*2=4,147,200字节。这个数不会变，你动态分配反而多此一举。

// 静态分配示例：摄像头帧缓冲区
#define FRAME_WIDTH  1920
#define FRAME_HEIGHT 1080
#define PIXEL_SIZE   2  // YUV422格式

static uint8_t frame_buffer[FRAME_WIDTH * FRAME_HEIGHT * PIXEL_SIZE];

void camera_capture(void) {
    // 直接使用frame_buffer，无需检查分配是否成功
    dma_transfer(frame_buffer, FRAME_WIDTH * FRAME_HEIGHT * PIXEL_SIZE);
}

1.2 动态分配：双刃剑

动态分配（malloc/free）确实灵活，但我在项目中见过太多人把它用成了“定时炸弹”。你想想，在嵌入式实时系统里，malloc可能因为内存碎片而失败，free可能因为野指针而崩溃——这些在ADAS里都是不可接受的。

动态分配的问题主要集中在三点：

• 碎片化：频繁分配释放会产生外部碎片，导致大块内存无法分配
• 不确定性：malloc的执行时间不固定，可能触发操作系统的内存整理
• 错误处理：必须检查返回值，但很多开发者会忽略

// 动态分配的正确姿势（但我不推荐在ADAS核心路径用）
typedef struct {
    uint32_t object_id;
    float    x, y, width, height;
    float    confidence;
} DetectionResult;

DetectionResult* create_detection_result(void) {
    DetectionResult* result = (DetectionResult*)malloc(sizeof(DetectionResult));
    if (result == NULL) {
        // 必须处理失败情况
        log_error("Failed to allocate detection result");
        return NULL;
    }
    return result;
}

void free_detection_result(DetectionResult* result) {
    if (result != NULL) {
        free(result);
        result = NULL;  // 防止野指针
    }
}

1.3 内存池：ADAS的最佳实践

内存池，这是我个人最推崇的方案。说白了，就是预先分配一大块内存，然后自己管理。这样既有静态分配的确定性，又有动态分配的灵活性。

为什么内存池适合ADAS？我给你分析一下：

• 无碎片：固定大小的块，分配释放不会产生碎片
• 确定性：分配和释放的时间是O(1)的，不会触发系统调用
• 可控性：可以监控内存使用情况，提前预警

// 一个简单的内存池实现
#define POOL_SIZE   64   // 块数量
#define BLOCK_SIZE  256  // 每块大小

typedef struct {
    uint8_t  memory[POOL_SIZE][BLOCK_SIZE];
    uint32_t free_mask;  // 位图标记空闲块
    uint32_t free_count;
} MemoryPool;

void pool_init(MemoryPool* pool) {
    pool->free_mask = 0xFFFFFFFF;  // 全部空闲
    pool->free_count = POOL_SIZE;
}

void* pool_alloc(MemoryPool* pool) {
    if (pool->free_count == 0) {
        return NULL;  // 池已满
    }
    
    // 找到第一个空闲块
    uint32_t index = __builtin_ctz(pool->free_mask);
    pool->free_mask &= ~(1 << index);
    pool->free_count--;
    
    return pool->memory[index];
}

void pool_free(MemoryPool* pool, void* ptr) {
    // 计算块索引
    uint32_t index = ((uint8_t*)ptr - pool->memory[0]) / BLOCK_SIZE;
    pool->free_mask |= (1 << index);
    pool->free_count++;
}

1.4 三种策略的对比

特性	静态分配	动态分配	内存池
分配时间	编译期	运行时（不确定）	运行时（O(1)）
内存碎片	无	有	无
灵活性	低	高	中
安全性	高	低	高
适用场景	固定大小数据	非实时路径	实时路径

1.5 实战建议

嗯，说了这么多，我总结一下在实际项目中的选择思路：

1. 先分析数据生命周期：如果数据在整个系统运行期间都存在，用静态分配
2. 再看数据大小是否固定：固定大小优先考虑内存池
3. 最后评估实时性要求：实时路径用内存池，非实时路径可以用动态分配

我记得有一次做ADAS域控制器，需要处理12路摄像头的数据。每路摄像头都需要一个帧缓冲区，还要有算法处理的中间结果。我用了静态分配做主缓冲区，内存池做算法中间结果的管理。整个系统跑了几个月，内存使用率一直稳定在85%左右，没有出现过一次分配失败。

这就是我想传达的核心思想：在ADAS系统里，内存分配不是“能用就行”，而是要“在最坏情况下也能可靠运行”。你想想看，当车辆以120km/h行驶时，系统突然因为内存分配失败而宕机——这种场景，我们做嵌入式的人必须提前想到。

---

公众号:蓝海资料掘金营，微信deep3321