LwIP 的内存管理——笔记

Mr_幼稚猿

已于 2024-03-12 15:32:54 修改

阅读量986

点赞数 22

分类专栏： LwIP学习专栏文章标签：笔记 c语言 stm32 tcp/ip 网络协议

于 2024-03-12 15:30:00 首次发布

本文链接：https://blog.csdn.net/qq_38801439/article/details/136638124

版权

LwIP学习专栏专栏收录该内容

1 篇文章 0 订阅

订阅专栏

1、LwIP的内存分配策略

LwIP的内存分配策略有3种，分别为：动态内存池策略、动态内存堆策略、C标准库的malloc和free内存分配策略。

1.1、动态内存池策略（POOL）

原理

用户只能申请大小固定的内存块，在内存初始化的时候，系统会将所有可用的内存区域划分为 N 块固定大小的内存，然后将这些内存块通过单链表的方式连接起来，用户在申请内存块的时候就直接从链表的头部取出一个内存块进行分配，同理释放内存块的时候也是很简单，直接将内存块释放到链表的头部即可，这样子分配内存的时间就是固定的，非常高效。但是缺点也是很明显的，用户只能申请固定大小的内存块，如果内存块无法满足用户的需求，那么则无法申请成功，而如果将内存块大小变大，那么在用户需要极小的内存的时候就会造成内存的浪费，这也是不适合的。
但由于协议栈里面有大量的协议首部，如 TCP 首部、UDP 首部，IP 首部，以太网首部等，这些协议首部长度都是固定不变的，那么我们就能采用这种方式分配这些固定大小的内存空间，这样子的效率就会大大提高，并且无论怎么申请与释放，都不会产生内存碎片，这就让系统能很稳定地运行。内存池示意图具体见下图：

动态内存池代码分析

在 LwIP 协议栈初始化(lwip_init(void))的时候， memp_init()会对内存池进行初始化，代码如下：

memp_init(void)
{
  u16_t i;

  /* for every pool: */
  for (i = 0; i < LWIP_ARRAYSIZE(memp_pools); i++) {
    memp_init_pool(memp_pools[i]);

#if LWIP_STATS && MEMP_STATS
    lwip_stats.memp[i] = memp_pools[i]->stats;
#endif
  }

#if MEMP_OVERFLOW_CHECK >= 2
  /* check everything a first time to see if it worked */
  memp_overflow_check_all();
#endif /* MEMP_OVERFLOW_CHECK >= 2 */
}

memp_pools[MEMP_MAX]结构体数组解析如下：

const struct memp_desc *const memp_pools[MEMP_MAX] = {
#define LWIP_MEMPOOL(name,num,size,desc) &memp_ ## name,
#include "lwip/priv/memp_std.h"
};

......
//MEMP_MAX由memp_std.h中的部分宏决定
typedef enum {
#define LWIP_MEMPOOL(name,num,size,desc)  MEMP_##name,
#include "lwip/priv/memp_std.h"
  MEMP_MAX
} memp_t;

......
struct memp_desc {
#if defined(LWIP_DEBUG) || MEMP_OVERFLOW_CHECK || LWIP_STATS_DISPLAY
  /** Textual description */
  const char *desc;
#endif /* LWIP_DEBUG || MEMP_OVERFLOW_CHECK || LWIP_STATS_DISPLAY */
#if MEMP_STATS
  /** Statistics */
  struct stats_mem *stats;
#endif
  /** Element size */
  u16_t size;
#if !MEMP_MEM_MALLOC
  /** Number of elements */
  u16_t num;
  /** Base address */
  u8_t *base;
  /** First free element of each pool. Elements form a linked list. */
  struct memp **tab;
#endif /* MEMP_MEM_MALLOC */
};

最终memp_pools[MEMP_MAX]编译内容如下(伪代码)：

#define LWIP_MEMPOOL_DECLARE(name,num,size,desc) \
  LWIP_DECLARE_MEMORY_ALIGNED(memp_memory_ ## name ## _base, ((num) * (MEMP_SIZE + MEMP_ALIGN_SIZE(size)))); \
    \
  LWIP_MEMPOOL_DECLARE_STATS_INSTANCE(memp_stats_ ## name) \
    \
  static struct memp *memp_tab_ ## name; \
    \
  const struct memp_desc memp_ ## name = { \
    DECLARE_LWIP_MEMPOOL_DESC(desc) \
    LWIP_MEMPOOL_DECLARE_STATS_REFERENCE(memp_stats_ ## name) \
    LWIP_MEM_ALIGN_SIZE(size), \
    (num), \
    memp_memory_ ## name ## _base, \
    &memp_tab_ ## name \
  };
 
eg:#define LWIP_MEMPOOL_DECLARE(TCP_PCB,5,sizeof(tcp_pcb),"TCP_PCB")

	LWIP_DECLARE_MEMORY_ALIGNED(memp_memory_TCP_PCB_base, (5 * (0 + sizeof(tcp_pcb)字节对齐))); 
		#define LWIP_DECLARE_MEMORY_ALIGNED(variable_name, size) u8_t memp_memory_TCP_PCB_base[5 * sizeof(tcp_pcb)字节对齐 + 4 - 1]
		
	LWIP_MEMPOOL_DECLARE_STATS_INSTANCE(memp_stats_TCP_PCB) 	
		memp_stats_TCP_PCB {
			const char *name;
			uin16_t err;
			uin16_t avail;
			uin16_t used;
			uin16_t max;
			uin16_t illegal;
		};
		
	static struct memp *memp_tab_TCP_PCB; 	
		struct memp {
			struct memp *next;
		};
	
	const struct memp_desc memp_TCP_PCB = { \
		DECLARE_LWIP_MEMPOOL_DESC(desc) \
			"TCP_PCB"
		LWIP_MEMPOOL_DECLARE_STATS_REFERENCE(memp_stats_ ## name) \
			&memp_stats_TCP_PCB
		LWIP_MEM_ALIGN_SIZE(size), \
			sizeof(tcp_pcb)字节对齐
		(num), \
			5
		memp_memory_ ## name ## _base, \
			memp_memory_TCP_PCB_base
		&memp_tab_ ## name \
			&memp_tab_TCP_PCB
	}

//--------------------------最终内容如下----------------------------------
	编译#define LWIP_MEMPOOL_DECLARE(TCP_PCB,5,sizeof(tcp_pcb),"TCP_PCB")时，最终的结果为：
		const struct memp_desc memp_TCP_PCB = { \
			"TCP_PCB"
			&memp_stats_TCP_PCB
			sizeof(tcp_pcb)字节对齐
			5
			memp_memory_TCP_PCB_base
			&memp_tab_TCP_PCB
		}
    而memp_pools[MEMP_MAX]中保存的就是编译出来的memp_TCP_PCB的地址，有多个地址，由memp_std.h中的宏定义决定；

memp_init_pool(const struct memp_desc *desc)函数比较简单，就是根据memp_pools[ ]中的每种memp_desc结构体描述进行初始化，即在每种memp_desc类型中将空闲内存块连接成单链表，并且使用 memset()函数将其内容清零，这样子就初始化完成了。如下图所示：

动态内存池的内存分配

用户通过memp_malloc 函数进行内存块申请，而内存块的大小就是指定的大小。其过程很简单，就是根据内存池的类型去选择从哪个内存池进行分配，因为不同类型的内存池中内存块大小是不一样的，比如 TCP_PCB 与 UDP_PCB 的大小就不一样，所以申请内存的时候传入的参数是内存池的类型而并非要申请的内存大小，系统中所有的内存池类型都会被记录在memp_pools 数组中，我们可以将该数组称之为内存池描述表。memp_malloc返回的memp是申请成功的内存地址。

memp_malloc(memp_t type)
{
  void *memp;
  LWIP_ERROR("memp_malloc: type < MEMP_MAX", (type < MEMP_MAX), return NULL;);
  memp = do_memp_malloc_pool(memp_pools[type]);
  return memp;
}

static void *do_memp_malloc_pool(const struct memp_desc *desc)
{
  struct memp *memp;
  SYS_ARCH_DECL_PROTECT(old_level); //定义一个int类型的old_level
  SYS_ARCH_PROTECT(old_level);
  memp = *desc->tab;//取出对应内存块中的第一个空闲内存块
  if (memp != NULL) {
    *desc->tab = memp->next;//移动*desc->tab 指针，指向下一个空闲内存块
    LWIP_ASSERT("memp_malloc: memp properly aligned",((mem_ptr_t)memp % MEM_ALIGNMENT) == 0);
    desc->stats->used++;
    if (desc->stats->used > desc->stats->max) {
      desc->stats->max = desc->stats->used;
    }
    SYS_ARCH_UNPROTECT(old_level);
    return ((u8_t *)memp + MEMP_SIZE);//返回内存块地址
  } else {
    desc->stats->err++;
    SYS_ARCH_UNPROTECT(old_level);
    LWIP_DEBUGF(MEMP_DEBUG | LWIP_DBG_LEVEL_SERIOUS, ("memp_malloc: out of memory in pool %s\n", desc->desc));
  }
  return NULL;
}

动态内存池的内存释放

用户通过memp_free函数进行内存释放，只需要把使用完毕的内存块的起始地址和内存块类型传入memp_free函数即可。

memp_free(memp_t type, void *mem)
{
  LWIP_ERROR("memp_free: type < MEMP_MAX", (type < MEMP_MAX), return;);
  if (mem == NULL) {
    return;
  }
  do_memp_free_pool(memp_pools[type], mem);
}

static void do_memp_free_pool(const struct memp_desc *desc, void *mem)
{
  struct memp *memp;
  SYS_ARCH_DECL_PROTECT(old_level);
  LWIP_ASSERT("memp_free: mem properly aligned",((mem_ptr_t)mem % MEM_ALIGNMENT) == 0);
  /* cast through void* to get rid of alignment warnings */
  memp = (struct memp *)(void *)((u8_t *)mem - MEMP_SIZE);//根据内存块的地址偏移得到内存块的起始地址，因为前面也说了，内存块中有一部分内容是内存分配器操作的，所以需要进行偏移。 
  SYS_ARCH_PROTECT(old_level);
  desc->stats->used--;
  memp->next = *desc->tab;//内存块的下一个就是链表中的第一个空闲内存块
  *desc->tab = memp;//将内存块插入到对应内存池的*desc->tab 中
  SYS_ARCH_UNPROTECT(old_level);
}

1.2、动态内存堆策略

原理

内存堆的的组织结构，它包括了内存数据结构与某些重要的全局变量，代码如下：

struct mem {
  mem_size_t next;//下一个内存块的地址偏移量，基地址是整个内存堆的起始地址
  mem_size_t prev;//上一个内存块的地址偏移量，基地址是整个内存堆的起始地址
  u8_t used;  //used 字段用于标记该内存是否已经被使用
};

#define MIN_SIZE             12

#define MIN_SIZE_ALIGNED     LWIP_MEM_ALIGN_SIZE(MIN_SIZE)
#define SIZEOF_STRUCT_MEM    LWIP_MEM_ALIGN_SIZE(sizeof(struct mem))
#define MEM_SIZE_ALIGNED     LWIP_MEM_ALIGN_SIZE(MEM_SIZE)

LWIP_DECLARE_MEMORY_ALIGNED(ram_heap, MEM_SIZE_ALIGNED + (2U * SIZEOF_STRUCT_MEM));//内存堆的大小是由此宏定义，ram_heap[10240 + 2 * 8]
#define LWIP_RAM_HEAP_POINTER ram_heap
#endif /* LWIP_RAM_HEAP_POINTER *///：ram_heap[]就是内核的内存堆空间，LWIP_RAM_HEAP_POINTER这个宏定义相当于重新命名 ram_heap。 

static u8_t *ram;//ram 是一个全局指针变量，指向内存堆对齐后的起始地址
static struct mem *ram_end;//mem 类型指针，指向内存堆中最后一个内存块
static sys_mutex_t mem_mutex;//互斥量，用户保护内存堆的互斥量，暂时未用
static struct mem * LWIP_MEM_LFREE_VOLATILE lfree;//mem 类型指针，指向内存堆中低地址的空闲内存块，简单来说就是空闲内存块链表指针。 
....

动态内存堆代码分析

在 LwIP 协议栈初始化(lwip_init(void))的时候， mem_init()会对内存堆进行初始化。
内存堆初始化的过程就是对所属的内存堆组织结构进行初始化，主要设置内存堆的起始地址，以及初始化空闲列表。根据用户配置的宏定义进行相关初始化，配置不同其实现也不同（可能为空），该函数源码如下：

mem_init(void)
{
  struct mem *mem;

  LWIP_ASSERT("Sanity check alignment",
              (SIZEOF_STRUCT_MEM & (MEM_ALIGNMENT - 1)) == 0);

  /* align the heap */
  ram = (u8_t *)LWIP_MEM_ALIGN(LWIP_RAM_HEAP_POINTER);//内存堆空间对齐，LWIP_RAM_HEAP_POINTER 宏定义就是ram_mem，内存堆对齐后的起始地址被记录在 ram 中
  /* initialize the start of the heap */
  mem = (struct mem *)(void *)ram;//在内存堆起始位置放置一个 mem 类型的结构体，因为初始化后的内存堆就是一个大的空闲内存块，每个空闲内存块的前面都需要放置一个 mem 结构体。
  mem->next = MEM_SIZE_ALIGNED;//下一个内存块的偏移量为 MEM_SIZE_ALIGNED，这相对于直接到内存堆的结束地址了。
  mem->prev = 0;//上一个内存块为空。
  mem->used = 0;//标记未被使用。
  /* initialize the end of the heap */
  ram_end = ptr_to_mem(MEM_SIZE_ALIGNED);//指针移动到内存堆末尾的位置，并且在那里放置一个 mem 类型的结构体，并初始化表示内存堆结束的内存块。
  ram_end->used = 1;//：标记已经使用了该内存块，因为结束的地方是没有内存块的，不能被分配出去，只能表示已经使用。
  ram_end->next = MEM_SIZE_ALIGNED;//此处仅表示已经到了内存堆的结束的地方，并无内存可以分配
  ram_end->prev = MEM_SIZE_ALIGNED;//此处仅表示已经到了内存堆的结束的地方，并无内存可以分配
  MEM_SANITY();

  /* initialize the lowest-free pointer to the start of the heap */
  lfree = (struct mem *)(void *)ram;//空闲内存块链表指针指向内存堆的起始地址，因为当前只有一个内存块。

  MEM_STATS_AVAIL(avail, MEM_SIZE_ALIGNED);//创建一个内存堆分配时候使用的互斥量，如果是无操作系统的情况，该语句等效于空。 

  if (sys_mutex_new(&mem_mutex) != ERR_OK) {
    LWIP_ASSERT("failed to create mem_mutex", 0);
  }
}

经过 mem_init() 函数后，内存堆会被初始化为两个内存块，第一个内存块(mem)的大小就是整个内存堆的大小，而第二个内存块(ram_end)就是结束内存块，其大小为 0，并且被标记为已使用状态，无法进行分配。值得注意的是，系统在运行的时候，随着内存的分配与释放，lfree指针的指向地址不断改变，都指向内存堆中低地址空闲内存块，而 ram_end 则不会改变，它指向系统中最后一个内存块，也就是内存堆的结束地址。初始化完成的示意图见下图所示。

动态内存堆的内存分配

        内存分配函数根据用户指定申请大小的内存空间进行分配内存，最小为MIN_SIZE。LwIP 中使用内存分配算法是First Fit，其分配原理就是在空闲内存块链表中遍历寻找，直到找到第一个合适用户需求大小的内存块进行分配，如果该内存块能进行分割，则将用户需要大小的内存块分割出来，剩下的空闲内存块则重新插入空闲内存块链表中。
        mem_malloc()函数是 LwIP 中内存分配函数，其参数是用户指定大小的内存字节数，如果申请成功则返回内存块的地址，如果内存没有分配成功，则返回 NULL。分配的内存空间会受到内存对齐的影响，可能会比申请的内存略大，比如用户需要申请 22 个字节的内存，而 CPU 是按照 4 字节内存对齐的，那么分配的时候就会申请 24 个字节的内存块。内存块在申请成功后返回的是内存块的起始地址，但是该内存并未进行初始化，可能
包含任意的随机数据，用户可以立即对其进行初始化或者写入有效数据以防止数据错误。
        此外内存堆是一个全局变量，在操作系统的环境中进行申请内存块是不安全的，所以 LwIP使用互斥量实现了对临界资源的保护，在多个线程同时申请或者释放的时候，会因为互斥量的保护而产生延迟。内存分配函数具体见代码如下：

void *mem_malloc(mem_size_t size_in)
{
  mem_size_t ptr, ptr2, size;
  struct mem *mem, *mem2;
  LWIP_MEM_ALLOC_DECL_PROTECT();
  if (size_in == 0) {
    return NULL;
  }
  size = (mem_size_t)LWIP_MEM_ALIGN_SIZE(size_in);//将用户申请的内存大小进行字节对齐操作。
  if (size < MIN_SIZE_ALIGNED) {  //如果用户申请的内存大小小于最小的内存对齐大小MIN_SIZE_ALIGNED，则设为最小的默认值。
    /* every data block must be at least MIN_SIZE_ALIGNED long */
    size = MIN_SIZE_ALIGNED;
  }
  if ((size > MEM_SIZE_ALIGNED) || (size < size_in)) {//如果申请的内存大小大于整个内存堆对齐后的大小，则返回 NULL，申请内存失败。 
    return NULL;
  }
  /* protect the heap from concurrent access */
  sys_mutex_lock(&mem_mutex);//获得互斥量，这一句代码在操作系统环境才起作用。
  LWIP_MEM_ALLOC_PROTECT();
    //遍历空闲内存块链表，直到找到第一个适合用户需求的内存块大小。 
    for (ptr = mem_to_ptr(lfree); ptr < MEM_SIZE_ALIGNED - size; ptr = ptr_to_mem(ptr)->next) {
      mem = ptr_to_mem(ptr);//得到这个内存块起始地址

      if ((!mem->used) && (mem->next - (ptr + SIZEOF_STRUCT_MEM)) >= size) {//如果该内存块是未使用的，并且它的大小不小于用户需要的大小加上 mem 结构体的大小，那么就满足用户的需求
        if (mem->next - (ptr + SIZEOF_STRUCT_MEM) >= (size + SIZEOF_STRUCT_MEM + MIN_SIZE_ALIGNED)) {
          //既然满足用户需求，那么这个内存块可能很大，不能直接分配给用户，否则就是太浪费了，那就看看这个内存块能不能切开，
          //如果能就将一部分分配给用户即可，程序能执行到这里，说明内存块能进行分割，那就通过内存块的起始地址与用户需求大小进行偏移，
          //得到剩下的的内存起始块地址 ptr2。 
          ptr2 = (mem_size_t)(ptr + SIZEOF_STRUCT_MEM + size);
          LWIP_ASSERT("invalid next ptr",ptr2 != MEM_SIZE_ALIGNED);
          /* create mem2 struct */
          mem2 = ptr_to_mem(ptr2);//将该地址后的内存空间作为分割之后新内存块 mem2，将起始地址转换为 mem 结构体用于记录内存块的信息。
          mem2->used = 0;//标记为未使用的内存块，并且将其插入空闲内存块链表中
          mem2->next = mem->next;
          mem2->prev = ptr;
          /* and insert it between mem and mem->next */
          mem->next = ptr2;
          mem->used = 1;//被分配出去的内存块 mem 标记为已使用状态。 

          if (mem2->next != MEM_SIZE_ALIGNED) {//如果 mem2 内存块的下一个内存块不是链表中最后一个内存块（结束地址），那就将它下一个的内存块的 prve 指向 mem2。 
            ptr_to_mem(mem2->next)->prev = ptr2;
          }
          MEM_STATS_INC_USED(used, (size + SIZEOF_STRUCT_MEM));
        } else {
          mem->used = 1;//如果不能分割，直接将分配的内存块标记为已使用即可。 
          MEM_STATS_INC_USED(used, mem->next - mem_to_ptr(mem));
        }
        if (mem == lfree) {//如果被分配出去的内存块是 lfree 指向的内存块，那么就需要重新给 lfree 赋值。 
          struct mem *cur = lfree;
          /* Find next free block after mem and update lowest free pointer */
          while (cur->used && cur != ram_end) {//找到第一个低地址的空闲内存块。 
            cur = ptr_to_mem(cur->next);
          }
          lfree = cur;//将 lfree 指向该内存块。 
          LWIP_ASSERT("mem_malloc: !lfree->used", ((lfree == ram_end) || (!lfree->used)));
        }
        LWIP_MEM_ALLOC_UNPROTECT();
        sys_mutex_unlock(&mem_mutex);//释放互斥量。 
        LWIP_ASSERT("mem_malloc: allocated memory not above ram_end.",(mem_ptr_t)mem + SIZEOF_STRUCT_MEM + size <= (mem_ptr_t)ram_end);
        LWIP_ASSERT("mem_malloc: allocated memory properly aligned.",((mem_ptr_t)mem + SIZEOF_STRUCT_MEM) % MEM_ALIGNMENT == 0);
        LWIP_ASSERT("mem_malloc: sanity check alignment",(((mem_ptr_t)mem) & (MEM_ALIGNMENT - 1)) == 0);

        MEM_SANITY();
        return (u8_t *)mem + SIZEOF_STRUCT_MEM + MEM_SANITY_OFFSET;//返回内存块可用的起始地址，因为内存块的块头需要使用 mem结构体保存内存块的基本信息。
      }
    }
  MEM_STATS_INC(err);
  LWIP_MEM_ALLOC_UNPROTECT();
  sys_mutex_unlock(&mem_mutex);
  LWIP_DEBUGF(MEM_DEBUG | LWIP_DBG_LEVEL_SERIOUS, ("mem_malloc: could not allocate %"S16_F" bytes\n", (s16_t)size));
  return NULL;
}

动态内存堆的内存释放

内存释放的操作也是比较简单的，LwIP 是这样子做的：它根据用户释放的内存块地址，通过偏移 mem 结构体大小得到正确的内存块起始地址，并且根据 mem 中保存的内存块信息进行释放、合并等操作，并将 used 字段清零，表示该内存块未被使用。 LwIP 为了防止内存碎片的出现，通过算法将内存相邻的两个空闲内存块进行合并，在释放内存块的时候，如果内存块与上一个或者下一个空闲内存块在地址上是连续的，那么就将这两个内存块进行合并。具体参见 mem_free() 函数。

2、LwIP 中的配置

LwIP 中，内存的选择是通过以下这几个宏值来决定的，根据用户对宏值的定义值来判断使用那种内存管理策略，具体如下：

MEM_LIBC_MALLOC：该宏定义是否使用 C 标准库自带的内存分配策略。该值默认情况下为 0，表示不使用 C 标准库自带的内存分配策略。

MEMP_MEM_MALLOC：该宏定义表示是否使用 LwIP 内存堆分配策略实现内存池分配（即：要从内存池中获取内存时，实际是从内存堆中分配）。默认情况下为 0，表示不从内存堆中分配，内存池为独立一块内存实现。与MEM_USE_POOLS 只能选择其一。

MEM_USE_POOLS：该宏定义表示是否使用 LwIP 内存池分配策略实现内存堆的分配（即：要从内存堆中获取内存时，实际是从内存池中分配）。默认情况下为 0，表示不使用从内存池中分配，内存堆为独立一块内存实现。与MEMP_MEM_MALLOC 只能选择其一。

Mr_幼稚猿

关注

22
点赞
踩
19

收藏

觉得还不错? 一键收藏
1
评论
LwIP 的内存管理——笔记

用户只能申请大小固定的内存块，在内存初始化的时候，系统会将所有可用的内存区域划分为 N 块固定大小的内存，然后将这些内存块通过单链表的方式连接起来，用户在申请内存块的时候就直接从链表的头部取出一个内存块进行分配，同理释放内存块的时候也是很简单，直接将内存块释放到链表的头部即可，这样子分配内存的时间就是固定的，非常高效。LwIP 为了防止内存碎片的出现，通过算法将内存相邻的两个空闲内存块进行合并，在释放内存块的时候，如果内存块与上一个或者下一个空闲内存块在地址上是连续的，那么就将这两个内存块进行合并。
复制链接

扫一扫