1.内存管理
内存管理，是指软件运行时对计算机内存资源的分配和使用的技术。其最主要的目的是如何高效、快速的分配，并且在适当的时候释放和回收内存资源。
C库中就有自带的malloc和free函数来实现分配和释放内存。
lwIP内存管理简介
lwIP内存池和内存堆的本质就是直接操作数组实现！
lwIP内存堆和内存池应用
- 接收数据：MAC内核的数据（内存堆和内存池可适用）；
- 发送数据：调用lwIP的API接口（lwIP一般选用内存堆申请内存）；
- 用户调用：可调用lwIP的内存池和内存堆API接口申请内存；
- 接口控制块：netconn、socket、raw接口（lwIP一般选用内存池申请内存）；
- 构建消息：API消息、数据包消息。
2.lwIP内存堆简介
lwIP内存堆是一种可变长分配策略，可以随意申请任意大小的内存。
First Fit算法
从低地址空间往高地址空间查找，从中切割出合适的块，并把剩余的部分返回到动态内存堆中。
优点：
- 内存浪费小、较简单，适合小内存管理；
- 确保高地址空间具有足够内存；
- 要求分配最小值及相邻的空闲块合并（有效防止内存碎片）。
缺点： - 分配和释放频繁，会造成内存碎片；
- 分配与释放时，从低地址开始查找，导致效率低。
这个算法是典型的时间换空间算法！
3.lwIP内存堆原理解析
要使用这些API，需要把宏MEM_LIBC_MALLOC配置项必须设置为0。
mem_init
lfree指针就是指向最低可用空间的指针。
初始化的时候先初始化ram指针，同时完成4字节对齐；然后把ram赋值给mem这个结构体，定义好next指向管理的内存堆大小对齐后的地址，prev和used都置零；同时还需要定义内存堆的尾部ram_end，计算得到最后的地址再向上偏移一个结构体的大小（需要对齐），初始化used为1（这是尾巴了不能使用），next和prev都是管理的内存堆大小；然后把lfree指向ram（初始化的时候这一片都没用），中间这一段就是可用空间。代码如下：
void
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);
/* initialize the start of the heap */
mem = (struct mem *)(void *)ram;
mem->next = MEM_SIZE_ALIGNED;
mem->prev = 0;
mem->used = 0;
/* initialize the end of the heap */
ram_end = ptr_to_mem(MEM_SIZE_ALIGNED);
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_malloc
首先对申请的大小进行赋值，完成4字节对齐；同时计算申请的大小，不能小于最小申请字节数（默认给定12字节）；判断申请空间的合法性（是否大于管理的总大小，对齐的size应该>=未对齐时），合法才能进行内存申请；对内存进行保护操作，进入申请，通过指针ptr指向第一个可用空间满足的内存块的首地址；然后进行判断，这个内存块used得=0而且剩余空间足够我需要的内存大小+结构体大小，满足了就把ptr指向这里，同时申请mem2这个结构体，used=0，next就是之前mem的next，pre就是之前的ptr；然后把mem的next更新为ptr，used=1；最后判断mem2是否在结尾处，不是的话还要把结尾的prev指向ptr；最后通过cur指针来找到最低可用地址，更新lfree。代码如下：
void *
mem_malloc(mem_size_t size_in)
{
mem_size_t ptr, ptr2, size;
struct mem *mem, *mem2;
#if LWIP_ALLOW_MEM_FREE_FROM_OTHER_CONTEXT
u8_t local_mem_free_count = 0;
#endif /* LWIP_ALLOW_MEM_FREE_FROM_OTHER_CONTEXT */
LWIP_MEM_ALLOC_DECL_PROTECT();
if (size_in == 0) {
return NULL;
}
/* Expand the size of the allocated memory region so that we can
adjust for alignment. */
size = (mem_size_t)LWIP_MEM_ALIGN_SIZE(size_in);
if (size < MIN_SIZE_ALIGNED) {
/* every data block must be at least MIN_SIZE_ALIGNED long */
size = MIN_SIZE_ALIGNED;
}
#if MEM_OVERFLOW_CHECK
size += MEM_SANITY_REGION_BEFORE_ALIGNED + MEM_SANITY_REGION_AFTER_ALIGNED;
#endif
if ((size > MEM_SIZE_ALIGNED) || (size < size_in)) {
return NULL;
}
/* protect the heap from concurrent access */
sys_mutex_lock(&mem_mutex);
LWIP_MEM_ALLOC_PROTECT();
#if LWIP_ALLOW_MEM_FREE_FROM_OTHER_CONTEXT
/* run as long as a mem_free disturbed mem_malloc or mem_trim */
do {
local_mem_free_count = 0;
#endif /* LWIP_ALLOW_MEM_FREE_FROM_OTHER_CONTEXT */
/* Scan through the heap searching for a free block that is big enough,
* beginning with the lowest free block.
*/
for (ptr = mem_to_ptr(lfree); ptr < MEM_SIZE_ALIGNED - size;
ptr = ptr_to_mem(ptr)->next) {
mem = ptr_to_mem(ptr);
#if LWIP_ALLOW_MEM_FREE_FROM_OTHER_CONTEXT
mem_free_count = 0;
LWIP_MEM_ALLOC_UNPROTECT();
/* allow mem_free or mem_trim to run */
LWIP_MEM_ALLOC_PROTECT();
if (mem_free_count != 0) {
/* If mem_free or mem_trim have run, we have to restart since they
could have altered our current struct mem. */
local_mem_free_count = 1;
break;
}
#endif /* LWIP_ALLOW_MEM_FREE_FROM_OTHER_CONTEXT */
if ((!mem->used) &&
(mem->next - (ptr + SIZEOF_STRUCT_MEM)) >= size) {
/* mem is not used and at least perfect fit is possible:
* mem->next - (ptr + SIZEOF_STRUCT_MEM) gives us the 'user data size' of mem */
if (mem->next - (ptr + SIZEOF_STRUCT_MEM) >= (size + SIZEOF_STRUCT_MEM + MIN_SIZE_ALIGNED)) {
/* (in addition to the above, we test if another struct mem (SIZEOF_STRUCT_MEM) containing
* at least MIN_SIZE_ALIGNED of data also fits in the 'user data space' of 'mem')
* -> split large block, create empty remainder,
* remainder must be large enough to contain MIN_SIZE_ALIGNED data: if
* mem->next - (ptr + (2*SIZEOF_STRUCT_MEM)) == size,
* struct mem would fit in but no data between mem2 and mem2->next
* @todo we could leave out MIN_SIZE_ALIGNED. We would create an empty
* region that couldn't hold data, but when mem->next gets freed,
* the 2 regions would be combined, resulting in more free memory
*/
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->used = 0;
mem2->next = mem->next;
mem2->prev = ptr;
/* and insert it between mem and mem->next */
mem->next = ptr2;
mem->used = 1;
if (mem2->next != MEM_SIZE_ALIGNED) {
ptr_to_mem(mem2->next)->prev = ptr2;
}
MEM_STATS_INC_USED(used, (size + SIZEOF_STRUCT_MEM));
} else {
/* (a mem2 struct does no fit into the user data space of mem and mem->next will always
* be used at this point: if not we have 2 unused structs in a row, plug_holes should have
* take care of this).
* -> near fit or exact fit: do not split, no mem2 creation
* also can't move mem->next directly behind mem, since mem->next
* will always be used at this point!
*/
mem->used = 1;
MEM_STATS_INC_USED(used, mem->next - mem_to_ptr(mem));
}
#if LWIP_ALLOW_MEM_FREE_FROM_OTHER_CONTEXT
mem_malloc_adjust_lfree:
#endif /* LWIP_ALLOW_MEM_FREE_FROM_OTHER_CONTEXT */
if (mem == lfree) {
struct mem *cur = lfree;
/* Find next free block after mem and update lowest free pointer */
while (cur->used && cur != ram_end) {
#if LWIP_ALLOW_MEM_FREE_FROM_OTHER_CONTEXT
mem_free_count = 0;
LWIP_MEM_ALLOC_UNPROTECT();
/* prevent high interrupt latency... */
LWIP_MEM_ALLOC_PROTECT();
if (mem_free_count != 0) {
/* If mem_free or mem_trim have run, we have to restart since they
could have altered our current struct mem or lfree. */
goto mem_malloc_adjust_lfree;
}
#endif /* LWIP_ALLOW_MEM_FREE_FROM_OTHER_CONTEXT */
cur = ptr_to_mem(cur->next);
}
lfree = cur;
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);
#if MEM_OVERFLOW_CHECK
mem_overflow_init_element(mem, size_in);
#endif
MEM_SANITY();
return (u8_t *)mem + SIZEOF_STRUCT_MEM + MEM_SANITY_OFFSET;
}
}
#if LWIP_ALLOW_MEM_FREE_FROM_OTHER_CONTEXT
/* if we got interrupted by a mem_free, try again */
} while (local_mem_free_count != 0);
#endif /* LWIP_ALLOW_MEM_FREE_FROM_OTHER_CONTEXT */
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;
}
mem_free
首先通过mem来从当前的可用地址向上偏移一个结构体变量的大小，相当于找到要删除的内存的结构体的首地址；然后进行检查是否合法；合法就开始释放，把used置0，然后判断删除的是否比lfree指向的最低地址小，如果是，那就要更新lfree；然后通过plug_holes来更新释放内存的上一个内存的prev和next指针，完成释放。代码如下：
static void
plug_holes(struct mem *mem)
{
struct mem *nmem;
struct mem *pmem;
LWIP_ASSERT("plug_holes: mem >= ram", (u8_t *)mem >= ram);
LWIP_ASSERT("plug_holes: mem < ram_end", (u8_t *)mem < (u8_t *)ram_end);
LWIP_ASSERT("plug_holes: mem->used == 0", mem->used == 0);
/* plug hole forward */
LWIP_ASSERT("plug_holes: mem->next <= MEM_SIZE_ALIGNED", mem->next <= MEM_SIZE_ALIGNED);
nmem = ptr_to_mem(mem->next);
if (mem != nmem && nmem->used == 0 && (u8_t *)nmem != (u8_t *)ram_end) {
/* if mem->next is unused and not end of ram, combine mem and mem->next */
if (lfree == nmem) {
lfree = mem;
}
mem->next = nmem->next;
if (nmem->next != MEM_SIZE_ALIGNED) {
ptr_to_mem(nmem->next)->prev = mem_to_ptr(mem);
}
}
/* plug hole backward */
pmem = ptr_to_mem(mem->prev);
if (pmem != mem && pmem->used == 0) {
/* if mem->prev is unused, combine mem and mem->prev */
if (lfree == mem) {
lfree = pmem;
}
pmem->next = mem->next;
if (mem->next != MEM_SIZE_ALIGNED) {
ptr_to_mem(mem->next)->prev = mem_to_ptr(pmem);
}
}
}
void
mem_free(void *rmem)
{
struct mem *mem;
LWIP_MEM_FREE_DECL_PROTECT();
if (rmem == NULL) {
LWIP_DEBUGF(MEM_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_SERIOUS, ("mem_free(p == NULL) was called.\n"));
return;
}
if ((((mem_ptr_t)rmem) & (MEM_ALIGNMENT - 1)) != 0) {
LWIP_MEM_ILLEGAL_FREE("mem_free: sanity check alignment");
LWIP_DEBUGF(MEM_DEBUG | LWIP_DBG_LEVEL_SEVERE, ("mem_free: sanity check alignment\n"));
/* protect mem stats from concurrent access */
MEM_STATS_INC_LOCKED(illegal);
return;
}
/* Get the corresponding struct mem: */
/* cast through void* to get rid of alignment warnings */
mem = (struct mem *)(void *)((u8_t *)rmem - (SIZEOF_STRUCT_MEM + MEM_SANITY_OFFSET));
if ((u8_t *)mem < ram || (u8_t *)rmem + MIN_SIZE_ALIGNED > (u8_t *)ram_end) {
LWIP_MEM_ILLEGAL_FREE("mem_free: illegal memory");
LWIP_DEBUGF(MEM_DEBUG | LWIP_DBG_LEVEL_SEVERE, ("mem_free: illegal memory\n"));
/* protect mem stats from concurrent access */
MEM_STATS_INC_LOCKED(illegal);
return;
}
#if MEM_OVERFLOW_CHECK
mem_overflow_check_element(mem);
#endif
/* protect the heap from concurrent access */
LWIP_MEM_FREE_PROTECT();
/* mem has to be in a used state */
if (!mem->used) {
LWIP_MEM_ILLEGAL_FREE("mem_free: illegal memory: double free");
LWIP_MEM_FREE_UNPROTECT();
LWIP_DEBUGF(MEM_DEBUG | LWIP_DBG_LEVEL_SEVERE, ("mem_free: illegal memory: double free?\n"));
/* protect mem stats from concurrent access */
MEM_STATS_INC_LOCKED(illegal);
return;
}
if (!mem_link_valid(mem)) {
LWIP_MEM_ILLEGAL_FREE("mem_free: illegal memory: non-linked: double free");
LWIP_MEM_FREE_UNPROTECT();
LWIP_DEBUGF(MEM_DEBUG | LWIP_DBG_LEVEL_SEVERE, ("mem_free: illegal memory: non-linked: double free?\n"));
/* protect mem stats from concurrent access */
MEM_STATS_INC_LOCKED(illegal);
return;
}
/* mem is now unused. */
mem->used = 0;
if (mem < lfree) {
/* the newly freed struct is now the lowest */
lfree = mem;
}
MEM_STATS_DEC_USED(used, mem->next - (mem_size_t)(((u8_t *)mem - ram)));
/* finally, see if prev or next are free also */
plug_holes(mem);
MEM_SANITY();
#if LWIP_ALLOW_MEM_FREE_FROM_OTHER_CONTEXT
mem_free_count = 1;
#endif /* LWIP_ALLOW_MEM_FREE_FROM_OTHER_CONTEXT */
LWIP_MEM_FREE_UNPROTECT();
}
4.lwIP内存池介绍
lwIP内存池是把连续的内存分成多个大小相同的内存空间，以链表的形式链接起来。
优点：
- 分配速度快；
- 防止内存碎片；
- 回收便捷。
缺点：
- 资源浪费；
- 申请大型内存可能申请失败。
这种算法是典型的空间换时间算法！
在lwIP中，内存池主要用于内核中固定数据结构的分配，例如UDP控制块、TCP控制块等。
实现lwIP内存池的文件
- memp_priv.h：定义memp和memp_desc结构体（连接内存块，管理链接的内存块）；
- memp_std.h：申请所需的内存池；
- memp.h：声明宏定义及函数提供外部文件使用；
- memp.c：编写相关分配内存池及回收资源函数。
-
memp_priv.h
主要就是定义了一个单向链表所需要的一些参数，有内存块的大小、内存块数量、基地址以及第一个空闲块地址。 -
memp_std.h
这些配置需要在lwipopts.h中启用；主要通过这些配置，来告诉程序需要申请的对应协议结构体的内存池。 -
memp.h
##name在C中就是替换的意思，所以在“MEMP_”后面接上memp_std.h里面宏定义的东西，接上的话就会变成类似“MEMP_RAW_PCB”，其中RAW_PCB就是那个宏指代的内容，替换进去就好；替换进去之后就可以获得MEMP_MAX的值；
通过一系列宏定义的替换皆可以得到下面的样子，就是定义了内存池的大小。 -
memp.c
这里一次就是声明了内存空间，声明了执行空闲的内存块指针，声明了一类内存池的描述符。
这里展开之后，就是对应不同协议的内存池的各种内存块数据的地址。图中展示的两个就相当于当前内存池中所保存的两块内存块的内容，如下图所示：
lwIP内存池函数
-
memp_init_pool()
定义一个结构体memp，初始化tab为NULL，然后获得对齐后的base地址传给memp；然后tab和next就会经过for循环不断向后遍历，最终构成如图所示的链表。 -
memp_malloc()
这个函数就是在内部调用do_memp_malloc_pool函数，被调用的函数传入的参数就是当前结构体变量的类型，就是前面enum出来的，是udp还是raw还是tcp的那个；这个函数中会定义memp获取当前的tab，然后把tab指向memp->next，更新当前的第一个空闲内存，然后返回申请的内存地址。 -
memp_free_pool()
这个函数会调用do_memp_free_pool函数，其中会把memp->mext指向当前的tab，然后更新tab为memp，以此来释放内存。
总结
内存管理这一块，内容其实都是类似的，比如正点原子stm32HAL库课程里面提高篇，就有给我们打下内存管理的基础；然后我在看FreeRTOS的课程里面，他的操作系统的管理方法，比如列表和列表项的内容，底层是双向链表，跟内存堆就很相似；相比之下lwIP的内存池就是单向链表代码其实更加清晰易懂，原理上还更好理解一点。
lwIP的内存管理，内存堆就是基础的那些malloc数组操作；内存池就是单向链表。
9818
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
