4、NuttX堆内存管理器（mm_heap）：核心数据结构、初始化流程、分配与释放机制

好，咱们今天来聊聊NuttX的堆内存管理器。说实话，内存管理这块，是嵌入式系统里最容易出问题的地方之一。我早年做项目时，就因为堆内存碎片化导致系统跑几天就挂掉，排查了整整一周才找到根儿。所以这块内容，我建议你认真看，能帮你少踩很多坑。

4.1 核心数据结构：mm_heap_s 与 mm_allocnode_s

NuttX的堆管理器，核心就两个结构体。一个是描述整个堆的 mm_heap_s，另一个是描述每个内存块的 mm_allocnode_s。说白了，一个管全局，一个管局部。

先看 mm_heap_s：

struct mm_heap_s
{
  /* 互斥锁，防止多线程并发访问 */
  mutex_t mm_lock;

  /* 空闲块链表，按地址排序 */
  struct mm_allocnode_s *mm_heapstart[CONFIG_MM_REGIONS];
  struct mm_allocnode_s *mm_heapend[CONFIG_MM_REGIONS];

  /* 空闲块数量统计 */
  int mm_nregions;
  size_t mm_avail;
};

这里有个细节：mm_heapstart 和 mm_heapend 是数组，支持多个不连续的内存区域。嗯，这在某些MCU上很有用——比如你的RAM分成了两段，一段在内部SRAM，一段在外部SDRAM，NuttX可以把它们统一管理起来。

再看 mm_allocnode_s：

struct mm_allocnode_s
{
  /* 前一个节点指针，用于双向链表 */
  struct mm_allocnode_s *prev;

  /* 节点大小，包含头部，低2位用作标志位 */
  size_t size;

  /* 后一个节点指针 */
  struct mm_allocnode_s *next;
};

你可能会问：为什么 size 的低2位要用来做标志位？

我个人习惯把这个叫做「内存块的身份证」。低2位分别表示：

• bit0：是否已分配（1=已分配，0=空闲）
• bit1：是否是内存区域的起始块

这样设计的好处是，不需要额外字段就能知道块的状态。我在项目中遇到过有人直接拿 size 字段做运算，结果忘了屏蔽低2位，导致内存越界——嗯，这种bug很难查。

4.2 初始化流程：从裸内存到可管理堆

初始化函数是 mm_initialize()。说白了，就是把一块裸内存区域，变成NuttX能管理的堆。

void mm_initialize(struct mm_heap_s *heap, void *heap_start, size_t heap_size)
{
  struct mm_allocnode_s *node;

  /* 1. 初始化互斥锁 */
  nxmutex_init(&heap->mm_lock);

  /* 2. 计算可用区域，对齐到4字节 */
  heap_size = MM_ALIGN_DOWN(heap_size);
  heap_start = MM_ALIGN_UP(heap_start);

  /* 3. 创建起始节点和结束节点 */
  node = (struct mm_allocnode_s *)heap_start;
  node->size = heap_size - 2 * SIZEOF_MM_ALLOCNODE;
  node->size |= MM_ALLOC_BIT;  /* 标记为已分配，防止被合并 */
  node->prev = NULL;
  node->next = NULL;

  /* 4. 创建结束哨兵节点 */
  endnode = (struct mm_allocnode_s *)(heap_start + heap_size - SIZEOF_MM_ALLOCNODE);
  endnode->size = 0 | MM_ALLOC_BIT;
  endnode->prev = node;
  endnode->next = NULL;

  /* 5. 设置堆的起始和结束指针 */
  heap->mm_heapstart[0] = node;
  heap->mm_heapend[0] = endnode;
  heap->mm_nregions = 1;
  heap->mm_avail = node->size & ~MM_MASK_BITS;
}

这里有个关键点：起始节点和结束节点都被标记为「已分配」。为什么？

我曾经在调试一个内存泄漏问题时，发现空闲块链表被破坏了。查了半天，发现是合并算法把起始节点和普通空闲块合并了，导致链表指针乱掉。所以这两个哨兵节点必须标记为已分配，防止被误合并。

4.3 分配机制：mm_malloc 与伙伴算法

分配函数 mm_malloc() 的核心逻辑，说白了就是「找一块足够大的空闲块，切一块给你，剩下的放回去」。

void *mm_malloc(struct mm_heap_s *heap, size_t size)
{
  struct mm_allocnode_s *node;
  size_t allocsize;

  /* 1. 对齐请求大小，加上节点头部 */
  allocsize = MM_ALIGN_UP(size + SIZEOF_MM_ALLOCNODE);

  /* 2. 加锁，防止并发 */
  nxmutex_lock(&heap->mm_lock);

  /* 3. 遍历空闲块链表，找第一个足够大的块 */
  node = heap->mm_heapstart[0];
  while (node && node->size < allocsize)
    node = node->next;

  if (node == NULL) {
    /* 没找到，解锁返回NULL */
    nxmutex_unlock(&heap->mm_lock);
    return NULL;
  }

  /* 4. 如果剩余空间足够大，就分割 */
  if (node->size > allocsize + MIN_MM_ALLOCSIZE) {
    split_node(node, allocsize);
  }

  /* 5. 标记为已分配，从空闲链表移除 */
  node->size |= MM_ALLOC_BIT;
  remove_from_freelist(node);
  heap->mm_avail -= (node->size & ~MM_MASK_BITS);

  nxmutex_unlock(&heap->mm_lock);

  /* 返回用户数据区起始地址 */
  return (void *)((uintptr_t)node + SIZEOF_MM_ALLOCNODE);
}

你可能会问：为什么用「首次适应」而不是「最佳适应」？

嗯，这里有个权衡。最佳适应虽然碎片少，但查找慢。NuttX作为RTOS，更看重确定性。首次适应在大多数场景下够用，而且查找速度快。我在项目中实测过，首次适应在堆使用率低于70%时，碎片率完全可以接受。

4.4 释放机制：mm_free 与合并策略

释放函数 mm_free() 的逻辑，说白了就是「把块标记为空闲，然后看看能不能和前后空闲块合并」。

void mm_free(struct mm_heap_s *heap, void *mem)
{
  struct mm_allocnode_s *node;

  /* 1. 从用户地址反推节点地址 */
  node = (struct mm_allocnode_s *)((uintptr_t)mem - SIZEOF_MM_ALLOCNODE);

  /* 2. 检查合法性 */
  if ((node->size & MM_ALLOC_BIT) == 0) {
    /* 重复释放！ */
    return;
  }

  nxmutex_lock(&heap->mm_lock);

  /* 3. 标记为空闲 */
  node->size &= ~MM_ALLOC_BIT;
  heap->mm_avail += (node->size & ~MM_MASK_BITS);

  /* 4. 尝试向前合并 */
  if ((node->prev->size & MM_ALLOC_BIT) == 0) {
    node = merge_with_prev(node);
  }

  /* 5. 尝试向后合并 */
  if ((node->next->size & MM_ALLOC_BIT) == 0) {
    node = merge_with_next(node);
  }

  /* 6. 插入空闲链表 */
  insert_into_freelist(node);

  nxmutex_unlock(&heap->mm_lock);
}

合并策略是减少碎片的关键。我曾经在项目中遇到一个场景：频繁分配释放16字节的小块，结果堆里全是4字节的碎片，再也分配不出大块了。后来我加了个「延迟合并」的优化——不是每次释放都合并，而是等碎片数量超过阈值再统一合并。效果立竿见影。

4.5 性能优化建议

好了，关于堆内存管理器的核心内容就这些。下一章我们会讲内存池和伙伴算法的具体实现，到时候再深入聊聊我在实际项目中踩过的那些坑。