LWIP 的动态内存管理机制可以有三种：C 运行时库自带的内存分配策略、动态内存堆(HEAP)分配策略和动态内存池(POOL)分配策略。
前两者二选一，不允许同时支持。一般我们默认使用后者，即动态内存堆(HEAP)分配策略。

/*
   ------------------------------------
   ---------- Memory options ----------
   ------------------------------------
*/
/**
 * MEM_LIBC_MALLOC==1: Use malloc/free/realloc provided by your C-library
 * instead of the lwip internal allocator. Can save code size if you
 * already use it.
 */
#ifndef MEM_LIBC_MALLOC
#define MEM_LIBC_MALLOC                 0
#endif

从注释上能看出，使用动态内存堆(HEAP)分配策略，能够节省代码空间。

动态内存堆分配策略：

动态内存堆分配策略可以有两种实现方式，
第一种：通过开辟一个内存堆，然后通过模拟 C 运行时库的内存分配策略来实现。
第二种：通过动态内存池的方式来实现，也即动态内存堆分配函数通过简单调用动态内存池(POOL)分配函数来完成其功能。

策略一：通过开辟一个内存堆，然后通过模拟 C 运行时库的内存分配策略来实现：

一般情况下，我们选择这种动态内存堆分配策略。
动态内存堆分配策略原理：
在一个事先定义好大小的内存块中进行管理，其内存分配的策略是采用最快合适（First Fit）方式。只要找到一个比所请求的内存大的空闲块，就从中切割出合适的块，并把剩余的部分返回到动态内存堆中。
分配的内存块有个最小大小的限制，要求请求的分配大小不能小于 MIN_SIZE，否则请求会被分配到 MIN_SIZE 大小的内存空间。
一般 MIN_SIZE 为 12 字节，在这 12 个字节中前几个字节会存放内存分配器管理用的私有数据，该数据区不能被用户程序修改，否则导致致命问题。
内存释放的过程是相反的过程，但分配器会查看该节点前后相邻的内存块是否空闲，如果空闲则合并成一个大的内存空闲块。
分配策略优缺点：

• 优点：内存浪费小，比较简单，适合用于小内存的管理；
• 缺点：如果频繁的动态分配和释放，可能会造成严重的内存碎片，如果在碎片情况严重的话，可能会导致内存分配不成功。

对于动态内存的使用，比较推荐的方法就是分配->释放->分配->释放，这种使用方法能够减少内存碎片。
下面具体来看看 LWIP 是怎么来实现这些函数的。
mem_init( ) ：内存堆的初始化函数，主要是告知内存堆的起止地址，以及初始化空闲列表，由 lwip 初始化时自己调用，该接口为内部私有接口，不对用户层开放。
mem_malloc( ) ：申请分配内存。将总共需要的字节数作为参数传递给该函数，返回值是指向最新分配的内存的指针，而如果内存没有分配好，则返回值是 NULL，分配的空间大小会收到内存对齐的影响，可能会比申请的略大。返回的内存是“没有“初始化的。这块内存可能包含任何随机的垃圾，你可以马上用有效数据或者至少是用零来初始化这块内存。内存的分配和释放，不能在中断函数里面进行。内存堆是全局变量，因此内存的申请、释放操作做了线程安全保护，如果有多个线程在同时进行内存申请和释放，那么可能会因为信号量的等待而导致申请耗时较长。
mem_calloc( ) ：是对 mem_malloc( )函数的简单包装，他有两个参数，分别为元素的数目和每个元素的大小，这两个参数的乘积就是要分配的内存空间的大小，与 mem_malloc()不同的是它会把动态分配的内存清零。有经验的程序员更喜欢使用 mem_ calloc ()，因为这样的话新分配内存的内容就不会有什么问题，调用 mem_ calloc ()肯定会清 0，并且可以避免调用 memset()。

策略二：通过动态内存池的方式来实现，也即动态内存堆分配函数通过简单调用动态内存池(POOL)分配函数来完成其功能。

在这种情况下，用户需要在头文件 lwippools.h 中定义宏 MEM_USE_POOLS 和 MEM_USE_CUSTOM_POOLS 为 1，同时还要开辟一些额外的缓冲池区，如下：

//摘自mem.c文件
* Define three pools with sizes 256, 512, and 1512 bytes
 * LWIP_MALLOC_MEMPOOL_START
 * LWIP_MALLOC_MEMPOOL(20, 256)
 * LWIP_MALLOC_MEMPOOL(10, 512)
 * LWIP_MALLOC_MEMPOOL(5, 1512)
 * LWIP_MALLOC_MEMPOOL_END

opt.h文件中，默认配置为：

/**
 * MEM_USE_POOLS==1: Use an alternative to malloc() by allocating from a set
 * of memory pools of various sizes. When mem_malloc is called, an element of
 * the smallest pool that can provide the length needed is returned.
 * To use this, MEMP_USE_CUSTOM_POOLS also has to be enabled.
 */
#ifndef MEM_USE_POOLS
#define MEM_USE_POOLS                   0
#endif

/**
 * MEM_USE_POOLS_TRY_BIGGER_POOL==1: if one malloc-pool is empty, try the next
 * bigger pool - WARNING: THIS MIGHT WASTE MEMORY but it can make a system more
 * reliable. */
#ifndef MEM_USE_POOLS_TRY_BIGGER_POOL
#define MEM_USE_POOLS_TRY_BIGGER_POOL   0
#endif

一般不做使用。

动态内存池(POOL)分配策略：

动态内存池(POOL)分配策略可以说是一个比较笨的分配策略了，
但其分配策略实现简单，内存的分配、释放效率高，可以有效防止内存碎片的产生。不过，他的缺点是会浪费部分内存。
为什么叫 POOL？这点很有趣，POOL 有很多种，而这点依赖于用户配置 LWIP 的方式。
例如用户在头文件 opt.h 文件中定义 LWIP_UDP 为 1，则在编译的时候与 UDP 类型内存池就会被建立；定义 LWIP_TCP 为 1，则在编译的时候与 TCP 类型内存池就会被建立。
另外，还有很多其他类型的内存池，如专门存放网络包数据信息的 PBUF_POOL、还有上面讲解动态内存堆分配策略时提到的 CUSTOM_POOLS 等等等等。
某种类型的 POOL 其单个大小是固定的，而分配该类 POOL 的个数是可以用户配置的，用户应该根据协议栈实际使用状况进行配置。把协议栈中所有的 POOL 挨个放到一起，并把它们放在一片连续的内存区域，这呈现给用户的就是一个大的缓冲池。
所以，所谓的缓冲池的内部组织应该是这样的：开始处放了 A 类型的 POOL 池 a 个，紧接着放上 B 类型的 POOL 池 b 个，再接着放上 C 类型的 POOL 池 c 个….直至最后 N 类型的 POOL 池 n 个。这一点很像 UC/OSII 中进程控制块和事件控制块，先开辟一堆各种类型的放那，你要用直接来取就是了。注意，这里的分配必须是以单个缓冲池为基本单位的，在这样的情况下，可能导致内存浪费的情况。这是很明显的啊，不解释。
下面来看看在 LWIP 实现中是怎么开辟出上面所论述的大大的缓冲池的。

static u8_t memp_memory[MEM_ALIGNMENT - 1 
#define LWIP_MEMPOOL(name,num,size,desc) + ( (num) * (MEMP_SIZE + MEMP_ALIGN_SIZE(size) ) )
#include "lwip/memp_std.h"
];

上面的代码定义了缓冲池所使用的内存缓冲区，很多人肯定会怀疑这到底是不是一个数组的定义。定义一个数组，里面居然还有 define 和 include 关键字。解决问题的关键就在于头文件 memp_std.h，它里面的东西可以被简化为诸多条 LWIP_MEMPOOL(name,num,size,desc)。
又由于用了 define 关键字将 LWIP_MEMPOOL(name,num,size,desc)定义为+((num) * (MEMP_SIZE + MEMP_ALIGN_SIZE(size)))，所以，memp_std.h 被编译后就为一条一条的+（），+（），+（），+（）….所以最终的数组 memp_memory 等价定义为：

static u8_t memp_memory [ MEM_ALIGNMENT – 1
+（）
+（）….]；

MEM_ALIGNMENT – 1 为对齐考虑。
协议栈还建立了一些与缓冲池管理的全局变量：
memp_num：这个静态数组用于保存各种类型缓冲池的成员数目
memp_sizes：这个静态数组用于保存各种类型缓冲池的结构大小
memp_tab：这个指针数组用于指向各种类型缓冲池当前空闲节点
实现的函数：
memp_init（）：内存池的初始化，主要是为每种内存池建立链表 memp_tab，其链表是逆序的，此外，如果有统计功能使能的话，也把记录了各种内存池的数目。
memp_malloc（）：如果相应的 memp_tab 链表还有空闲的节点，则从中切出一个节点返回，否则返回空。
memp_free（）：把释放的节点添加到相应的链表 memp_tab 头上。

示例：

/** This array holds the number of elements in each pool. */
static const u16_t memp_num[MEMP_MAX] = {
#define LWIP_MEMPOOL(name,num,size,desc)  (num),
#include "lwip/memp_std.h"
};

进入lwip/memp_std.h展开：

static const u16_t memp_num[MEMP_MAX] = {
(MEMP_NUM_RAW_PCB),//4
(MEMP_NUM_UDP_PCB),//6
(MEMP_NUM_TCP_PCB),//10
(MEMP_NUM_TCP_PCB_LISTEN),//6
(MEMP_NUM_TCP_SEG),//15
(MEMP_NUM_REASSDATA),//5
(MEMP_NUM_NETBUF),//2
(MEMP_NUM_NETCONN),
(MEMP_NUM_TCPIP_MSG_INPKT),//8
(MEMP_NUM_SYS_TIMEOUT),//8

具体的数字，以项目需要为主，项目不同，可能数值不同。

memp_std.h实现技巧：

部分代码如下：

#ifndef LWIP_MALLOC_MEMPOOL
/* This treats "malloc pools" just like any other pool.
   The pools are a little bigger to provide 'size' as the amount of user data. */
#define LWIP_MALLOC_MEMPOOL(num, size) LWIP_MEMPOOL(POOL_##size, num, (size + sizeof(struct memp_malloc_helper)), "MALLOC_"#size)
#define LWIP_MALLOC_MEMPOOL_START
#define LWIP_MALLOC_MEMPOOL_END
#endif /* LWIP_MALLOC_MEMPOOL */ 

#ifndef LWIP_PBUF_MEMPOOL
/* This treats "pbuf pools" just like any other pool.
 * Allocates buffers for a pbuf struct AND a payload size */
#define LWIP_PBUF_MEMPOOL(name, num, payload, desc) LWIP_MEMPOOL(name, num, (MEMP_ALIGN_SIZE(sizeof(struct pbuf)) + MEMP_ALIGN_SIZE(payload)), desc)
#endif /* LWIP_PBUF_MEMPOOL */


/*
 * A list of internal pools used by LWIP.
 *
 * LWIP_MEMPOOL(pool_name, number_elements, element_size, pool_description)
 *     creates a pool name MEMP_pool_name. description is used in stats.c
 */
#if LWIP_RAW
LWIP_MEMPOOL(RAW_PCB,        MEMP_NUM_RAW_PCB,         sizeof(struct raw_pcb),        "RAW_PCB")
#endif /* LWIP_RAW */

#if LWIP_TCP
LWIP_MEMPOOL(TCP_PCB,        MEMP_NUM_TCP_PCB,         sizeof(struct tcp_pcb),        "TCP_PCB")
LWIP_MEMPOOL(TCP_PCB_LISTEN, MEMP_NUM_TCP_PCB_LISTEN,  sizeof(struct tcp_pcb_listen), "TCP_PCB_LISTEN")
LWIP_MEMPOOL(TCP_SEG,        MEMP_NUM_TCP_SEG,         sizeof(struct tcp_seg),        "TCP_SEG")
#endif /* LWIP_TCP */
......
/*
 * A list of pools of pbuf's used by LWIP.
 *
 * LWIP_PBUF_MEMPOOL(pool_name, number_elements, pbuf_payload_size, pool_description)
 *     creates a pool name MEMP_pool_name. description is used in stats.c
 *     This allocates enough space for the pbuf struct and a payload.
 *     (Example: pbuf_payload_size=0 allocates only size for the struct)
 */
LWIP_PBUF_MEMPOOL(PBUF,      MEMP_NUM_PBUF,            0,                             "PBUF_REF/ROM")
LWIP_PBUF_MEMPOOL(PBUF_POOL, PBUF_POOL_SIZE,           PBUF_POOL_BUFSIZE,             "PBUF_POOL")


/*
 * Allow for user-defined pools; this must be explicitly set in lwipopts.h
 * since the default is to NOT look for lwippools.h
 */
#if MEMP_USE_CUSTOM_POOLS
#include "lwippools.h"
#endif /* MEMP_USE_CUSTOM_POOLS */

/*
 * REQUIRED CLEANUP: Clear up so we don't get "multiply defined" error later
 * (#undef is ignored for something that is not defined)
 */
#undef LWIP_MEMPOOL
#undef LWIP_MALLOC_MEMPOOL
#undef LWIP_MALLOC_MEMPOOL_START
#undef LWIP_MALLOC_MEMPOOL_END
#undef LWIP_PBUF_MEMPOOL

语法#undef，即取消前端的定义的相关宏。
前边的示例中，静态数组中定义了

#define LWIP_MEMPOOL(name,num,size,desc)  (num),

之后进入了本章的memp_std.h文件，并在文件的最后取消了定义

#undef LWIP_MALLOC_MEMPOOL

实现该头文件的重用。

最后

以上就是饱满小蜜蜂为你收集整理的LwIP 协议栈源码分析(读书笔记)--内存管理--机制策略分析动态内存堆分配策略：动态内存池(POOL)分配策略：示例：memp_std.h实现技巧：的全部内容，希望文章能够帮你解决LwIP 协议栈源码分析(读书笔记)--内存管理--机制策略分析动态内存堆分配策略：动态内存池(POOL)分配策略：示例：memp_std.h实现技巧：所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。