LwIP系列--内存管理（内存池）详解

已于 2023-02-02 11:29:40 修改
阅读量3k 收藏 18
点赞数 5
分类专栏： LwIP 文章标签： tcp/ip mcu Powered by 金山文档
于 2023-01-25 20:47:18 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tianizimark/article/details/128730439
版权

一、目的

在《LwIP系列--内存管理（堆内存）详解》中我们详细介绍了LwIP中内存堆的实现原理，本篇我们介绍LwIP中内存池的实现细节。

在LwIP源码中为了满足特定内存分配的需要以及优化内存占用制定了各种尺寸大小的内存池（每种内存池管理的内存块大小固定）。

内存池分配方案的特点：

  • 每个内存块大小固定（由于根据大小从不同内存池中获取内存块，故内存堆的内存碎片得到优化）

  • 不存在内存碎片

  • 分配时间相对固定

因为LwIP需要根据TCP/IP协议各层需要不同大小的数据包，故针对不同层和协议制定了不同大小的内存池。

内存堆示意图

上图中定义了A/B/C各种尺寸的内存池，内存池A管理着A-1/A-2/A3等内存块，每个内存池可以有不同数量相同大小的内存块，不同内存池中的内存块的大小一般不相同。

二、介绍

在正式介绍内存池实现细节之前我们先理解跟内存池相关的宏定义和结构体，LwIP在内存池的实现上定义了各种宏定义

宏定义说明
LWIP_DEBUG
MEMP_OVERFLOW_CHECK
LWIP_STATS_DISPLAY
MEMP_STATS
MEMP_MEM_MALLOC

LWIP_DEBUG定义是否调试LwIP内核

MEMP_OVERFLOW_CHECK定义是否进行内存池溢出检查

LWIP_STATS_DISPLAY定义是否进行统计数据显示

MEMP_STATS定义是否打开内存池统计

MEMP_MEM_MALLOC定义内存池的分配和释放是否使用mem_malloc/mem_free（也就是不使用内存池的分配算法而使用动态内存堆方式进行分配）

MEMP_SIZE宏定义
#if MEMP_OVERFLOW_CHECK


/* MEMP_SIZE: save space for struct memp and for sanity check */
#define MEMP_SIZE          (LWIP_MEM_ALIGN_SIZE(sizeof(struct memp)) + MEM_SANITY_REGION_BEFORE_ALIGNED)
#define MEMP_ALIGN_SIZE(x) (LWIP_MEM_ALIGN_SIZE(x) + MEM_SANITY_REGION_AFTER_ALIGNED)

#else /* MEMP_OVERFLOW_CHECK */

/* No sanity checks
 * We don't need to preserve the struct memp while not allocated, so we
 * can save a little space and set MEMP_SIZE to 0.
 */
#define MEMP_SIZE           0
#define MEMP_ALIGN_SIZE(x) (LWIP_MEM_ALIGN_SIZE(x))

#endif /* MEMP_OVERFLOW_CHECK */

如果定义了MEMP_OVERFLOW_CHECK宏，则内存池中的每个内存块头部都会有内存块管理结构用于内存块的完整性检查

内存池描述
/** Memory pool descriptor */
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 */
};

各字段含义说明：

desc：内存池的字符串描述（在调试、内存池溢出检查、数据统计时定义该字段）

stats：内存池统计信息，包括可用内存，最大内存、已经分配的内存信息（定义MEMP_STATS时定义该字段）

size：记录内存池中每个内存块的大小

num：记录该内存池中有几个内存块

base：内存池的首地址

tab：通过此字段将内存块构成链表进行管理（指向空闲的第一个内存块）

其中size/num/base/tab定义了内存池的几个关键字段（在MEMP_MEM_MALLOC=0时定义这些字段）

/** Memory stats */
struct stats_mem {
#if defined(LWIP_DEBUG) || LWIP_STATS_DISPLAY
  const char *name;
#endif /* defined(LWIP_DEBUG) || LWIP_STATS_DISPLAY */
  STAT_COUNTER err;
  mem_size_t avail;
  mem_size_t used;
  mem_size_t max;
  STAT_COUNTER illegal;
};

结构体stats_mem定义了内存的使用信息

各字段如下：

name：此结构体变量的描述性信息（用于指示属于某个内存结构）

err： 内存分配出错的次数

avail：可用内存

used：已使用内存

max：最大内存

#if !MEMP_MEM_MALLOC || MEMP_OVERFLOW_CHECK
struct memp {
  struct memp *next;
#if MEMP_OVERFLOW_CHECK
  const char *file;
  int line;
#endif /* MEMP_OVERFLOW_CHECK */
};
#endif /* !MEMP_MEM_MALLOC || MEMP_OVERFLOW_CHECK */

各个字段的含义：

next：下一个内存块的地址

file：调用内存池分配函数的文件

line：调用内存池分配函数的行数

内存池类型

在LwIP中定义了各种类型的内存池，故使用一个枚举类型来标记不同的类型的内存池

/** Create the list of all memory pools managed by memp. MEMP_MAX represents a NULL pool at the end */
typedef enum {
#define LWIP_MEMPOOL(name,num,size,desc)  MEMP_##name,
#include "lwip/priv/memp_std.h"
  MEMP_MAX
} memp_t;

注意宏定义LWIP_MEMPOOL的定义

##用于拼接字符串

上面的代码片段定义了memp_t枚举类型，MEMP_MAX定义了memp_t枚举类型的最大值。

举例说明

LWIP_MEMPOOL(MYPOOL, 4, 16, "my pool type")
//相当于定义枚举值MEMP_MYPOOL

在memp_std.h头文件中的定义了各种内存池

/*
 * 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_UDP
LWIP_MEMPOOL(UDP_PCB,        MEMP_NUM_UDP_PCB,         sizeof(struct udp_pcb),        "UDP_PCB")
#endif /* LWIP_UDP */

#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 */

#if LWIP_ALTCP && LWIP_TCP
LWIP_MEMPOOL(ALTCP_PCB,      MEMP_NUM_ALTCP_PCB,       sizeof(struct altcp_pcb),      "ALTCP_PCB")
#endif /* LWIP_ALTCP && LWIP_TCP */

上面的代码中定义了MEMP_RAW_PCB/MEMP_UDP_PCB/MEMP_TCP_PCB/MEMP_TCP_PCB_LISTEN/MEMP_TCP_SEG/MEMP_ALTCP_PCB这些枚举值，即存在这些类型的内存池

定义内存池
#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 \
  };

各个字段的含义：

name：内存池的名字

num：内存池中内存块的个数

size：内存池中每个内存块的大小

desc：内存池的描述字符串

举例说明：

LWIP_MEMPOOL_DECLARE(mypool, 4, 16, "my pool")

上面的代码片段宏展开后的代码如下：

u8_t memp_memory_mypool_base[4 * (MEMP_SIZE + 16)];
static struct stats_mem memp_stats_mypool;
static struct memp *memp_tab_mypool;
const struct memp_desc memp_mypool = {
    "my pool",
    &memp_stats_mypool,
    16,
    4,
    memp_memory_mypool_base,
    &memp_tab_mypool
};

其中MEMP_SIZE用于完整性检查，一般定义MEMP_SIZE为0即可；

在上面的代码中我们通过LWIP_MEMPOOL_DECLARE宏定义就定义了一个新的内存池mypool以及相关的内存以及描述信息。

memp_memory_mypool_base数组就是内存池需要的内存空间

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

每个内存池都有一个内存池描述，这些内存池描述组成了内存池集合，即LwIP管理的所有内存池

内存池初始化
#define LWIP_MEMPOOL_INIT(name)    memp_init_pool(&memp_ ## name)

/**
 * Initialize custom memory pool.
 * Related functions: memp_malloc_pool, memp_free_pool
 *
 * @param desc pool to initialize
 */
void
memp_init_pool(const struct memp_desc *desc)
{
#if MEMP_MEM_MALLOC    //①
  LWIP_UNUSED_ARG(desc);
#else
  int i;
  struct memp *memp;

  *desc->tab = NULL;
  memp = (struct memp *)LWIP_MEM_ALIGN(desc->base);    //②
#if MEMP_MEM_INIT                                //③
  /* force memset on pool memory */
  memset(memp, 0, (size_t)desc->num * (MEMP_SIZE + desc->size 
#if MEMP_OVERFLOW_CHECK
                                       + MEM_SANITY_REGION_AFTER_ALIGNED
#endif
                                      ));
#endif
  /* create a linked list of memp elements */
  for (i = 0; i < desc->num; ++i) {  //④
    memp->next = *desc->tab;
    *desc->tab = memp;
#if MEMP_OVERFLOW_CHECK
    memp_overflow_init_element(memp, desc);
#endif /* MEMP_OVERFLOW_CHECK */
    /* cast through void* to get rid of alignment warnings */
    memp = (struct memp *)(void *)((u8_t *)memp + MEMP_SIZE + desc->size
#if MEMP_OVERFLOW_CHECK
                                   + MEM_SANITY_REGION_AFTER_ALIGNED
#endif
                                  );
  }
#if MEMP_STATS                
  desc->stats->avail = desc->num;
#endif /* MEMP_STATS */
#endif /* !MEMP_MEM_MALLOC */

#if MEMP_STATS && (defined(LWIP_DEBUG) || LWIP_STATS_DISPLAY)
  desc->stats->name  = desc->desc;
#endif /* MEMP_STATS && (defined(LWIP_DEBUG) || LWIP_STATS_DISPLAY) */
}

①MEMP_MEM_MALLOC宏定义代表使用内存堆的分配方式作为内存池实现，此处我们讲解的是内存池的实现原理，故未定义此宏

②对栈上变量memp进行赋值

③对memp开始的地址进行清零操作

④对内存块管理结构进行赋值（将各个内存块通过next指针链接起来）

初始化后的内存布局如下：

第一个内存块的next指针为NULL，第二个内存块的next指向第一个内存块，依次类推；最终内存块的描述结构desc->tab指向内存池最后一个内存块

从内存池中分配内存
#define LWIP_MEMPOOL_ALLOC(name)   memp_malloc_pool(&memp_ ## name)

举例如果从刚才定义的mypool内存池中分配内存就可以这样操作

void *ptr = LWIP_MEMPOOL_ALLOC(mypool)
//也可以
void *ptr = memp_malloc_pool(&memp_mypool);
void *
#if !MEMP_OVERFLOW_CHECK
memp_malloc_pool(const struct memp_desc *desc)
#else
memp_malloc_pool_fn(const struct memp_desc *desc, const char *file, const int line)
#endif
{
  LWIP_ASSERT("invalid pool desc", desc != NULL);
  if (desc == NULL) {
    return NULL;
  }

#if !MEMP_OVERFLOW_CHECK
  return do_memp_malloc_pool(desc);
#else
  return do_memp_malloc_pool_fn(desc, file, line);
#endif
}
static void *
#if !MEMP_OVERFLOW_CHECK
do_memp_malloc_pool(const struct memp_desc *desc)
#else
do_memp_malloc_pool_fn(const struct memp_desc *desc, const char *file, const int line)
#endif
{
  struct memp *memp;
  SYS_ARCH_DECL_PROTECT(old_level);    //①

#if MEMP_MEM_MALLOC
  memp = (struct memp *)mem_malloc(MEMP_SIZE + MEMP_ALIGN_SIZE(desc->size));
  SYS_ARCH_PROTECT(old_level);
#else /* MEMP_MEM_MALLOC */
  SYS_ARCH_PROTECT(old_level);

  memp = *desc->tab;                //②
#endif /* MEMP_MEM_MALLOC */

  if (memp != NULL) {
#if !MEMP_MEM_MALLOC
#if MEMP_OVERFLOW_CHECK == 1
    memp_overflow_check_element(memp, desc);
#endif /* MEMP_OVERFLOW_CHECK */

    *desc->tab = memp->next;            //③
#if MEMP_OVERFLOW_CHECK
    memp->next = NULL;
#endif /* MEMP_OVERFLOW_CHECK */
#endif /* !MEMP_MEM_MALLOC */
#if MEMP_OVERFLOW_CHECK
    memp->file = file;
    memp->line = line;
#if MEMP_MEM_MALLOC
    memp_overflow_init_element(memp, desc);
#endif /* MEMP_MEM_MALLOC */
#endif /* MEMP_OVERFLOW_CHECK */
    LWIP_ASSERT("memp_malloc: memp properly aligned",
                ((mem_ptr_t)memp % MEM_ALIGNMENT) == 0);
#if MEMP_STATS
    desc->stats->used++;
    if (desc->stats->used > desc->stats->max) {
      desc->stats->max = desc->stats->used;
    }
#endif
    SYS_ARCH_UNPROTECT(old_level);
    /* cast through u8_t* to get rid of alignment warnings */
    return ((u8_t *)memp + MEMP_SIZE);  //④
  } else {
#if MEMP_STATS
    desc->stats->err++;
#endif
    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;
}

①分配内存时先进行保护

②获取内存池第一个空闲块的地址

③将内存池空闲块的指针指向当前块的下一个，并将当前块的next设置为NULL

④将获取的空闲内存块的地址返回（此处是memp + MEMP_SIZE）

上图从内存池中分配一个内存块后的内存布局

上图是从内存池中再次分配一个内存块后的内存布局

释放内存
#define LWIP_MEMPOOL_FREE(name, x) memp_free_pool(&memp_ ## name, (x))
/**
 * Put a custom pool element back into its pool.
 *
 * @param desc the pool where to put mem
 * @param mem the memp element to free
 */
void
memp_free_pool(const struct memp_desc *desc, void *mem)
{
  LWIP_ASSERT("invalid pool desc", desc != NULL);
  if ((desc == NULL) || (mem == NULL)) {
    return;
  }

  do_memp_free_pool(desc, 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);    //③

#if MEMP_OVERFLOW_CHECK == 1
  memp_overflow_check_element(memp, desc);
#endif /* MEMP_OVERFLOW_CHECK */

#if MEMP_STATS
  desc->stats->used--;
#endif

#if MEMP_MEM_MALLOC
  LWIP_UNUSED_ARG(desc);
  SYS_ARCH_UNPROTECT(old_level);
  mem_free(memp);
#else /* MEMP_MEM_MALLOC */
  memp->next = *desc->tab;   //④
  *desc->tab = memp;  //⑤

#if MEMP_SANITY_CHECK
  LWIP_ASSERT("memp sanity", memp_sanity(desc));
#endif /* MEMP_SANITY_CHECK */

  SYS_ARCH_UNPROTECT(old_level);
#endif /* !MEMP_MEM_MALLOC */
}

①声明保护

②获取内存块的首地址

③对释放过程进行保护

④将要释放的内存块的next指向内存池中的空闲块的地址

⑤将内存池的空闲块指针指向当前块

上图中内存块D释放后的内存布局

至此，我们基本讲解完了LwIP的内存池实现（原理上还是很简单的）

coder.mark
关注
  • 5
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
LwIP 之六 详解内存池（memp.c/h）动态内存管理策略
技术干货
08-01 8678
对于嵌入式开发来说，内存管理及使用是至关重要的，内存的使用多少、内存泄漏等时刻需要注意！合理的内存管理策略将从根本上决定内存分配和回收效率，最终决定系统的整体性能。LwIP 就提供了 动态内存堆管理（heap）和 动态内存池管理（pool）两种简单却又高效的动态内存管理机制。
LWIP_LwIP_
09-30
实现了客户端网络连接，实现了串口打印，LCD显示状态，LWIP移植
【lwIP（第三章）】内存管理
K3169的博客
03-26 2155
内存管理，是指软件运行时对计算机内存资源的分配和使用的技术。其最主要的目的是如何高效、快速的分配，并且在适当的时候释放和回收内存资源。
LwIP 的内存管理——笔记
qq_38801439的博客
03-12 965
用户只能申请大小固定的内存块，在内存初始化的时候，系统会将所有可用的内存区域划分为 N 块固定大小的内存，然后将这些内存块通过单链表的方式连接起来，用户在申请内存块的时候就直接从链表的头部取出一个内存块进行分配，同理释放内存块的时候也是很简单，直接将内存块释放到链表的头部即可，这样子分配内存的时间就是固定的，非常高效。LwIP 为了防止内存碎片的出现，通过算法将内存相邻的两个空闲内存块进行合并，在释放内存块的时候，如果内存块与上一个或者下一个空闲内存块在地址上是连续的，那么就将这两个内存块进行合并。
lwIP-1.4.1内存管理的一点记录与总结
06-12
lwIP-1.4.1 TCP/IP协议栈中关于内存管理的一点记录与总结，可作为移植开发中的一个参考手册。
官网最新lwip--2.0.0
05-02
官网最新资源共享，资料完整，官网首发！！！！！！！！！！！！！
《lwip学习3》-- 内存管理
qq_40831436的博客
09-23 1661
lwip内存管理
LwIP系列--内存管理（堆内存）详解
coderma的博客
01-21 2773
Lwip内存堆管理算法
LWIP 学习（2）内存管理
weixin_42197635的博客
04-28 403
就使用上面的 RAW_PCB 的例子，每种 POOL 在经过编译器都会得到一个结构体，memp_desc memp_XXXX，XXXX 表示对应的 POOL 类型，如RAW_PCB 的结构体就是 memp_desc memp_RAW_PCB，这里面就记录了该内存块对其后的大。，然后将这些内存块通过单链表的方式连接起来，用户在申请内存块的时候就直接从链表的头部取出一个内存块进行分配，同理释放内存块的时候也是很简单，直接将内存块释放到链表的头部即可。频繁的进行动态内存分配和释放，可能造成严重的内存碎片。
LWIP之Memp原理
weixin_44487162的博客
01-25 1251
前言 在这个色彩缤纷的时代，网络扮演着重要的角色，作为网络通讯的主要协议，TCP/IP协议就变得非常的重要，对于嵌入式系统来说，处理能力以及内存上的瓶颈导致嵌入式TCP/IP协议栈不可能像PC上的协议栈那么强大，而LWIP作为一个小型的开源免费的TCP/IP协议栈，以简洁，高效，占用内存少被广泛的使用在各类嵌入式网络应用中，本文就是基于LWIP的内存角度开展的。 正文 本文将从三个角度来分析LWIP的memp内存池机制。 【1】memp相关宏以及变量的解释 【2】Memp的内存...
IIC-LWIP使用总结
weixin_43637946的博客
11-08 388
一、硬件IIC与模拟IIC 1)STM32F10X的硬件IIC勘误说明 当不能在传输当前字节之前和当改变ACK控制位送出相应脉冲之前，处理EV7、EV7_1、EV6_1、EV2、EV8和EV3事件时，建议如下操作： 使用I2C的DMA模式，除非作为主设备时只接收一个字节。 使用I2C的中断并把它的优先级设为最高级别，使得它不能被中断。 2)模拟IIC 利用IO口，模拟出开始信号、停止信号、发送AC...
lwip内存管理_单片机内存管理_
10-04
从lwip裁剪下来的
lwip-2.1.3.zip
12-23
lwIP 2.1.3 released posted by goldsimon, Wed 10 Nov 2021 06:52:43 PM UTC - 0 replies lwIP 2.1.3 is now available from the lwIP download area or via git (using the STABLE-2_1_3_RELEASE tag). This is again a bugfix-only release on the 2.1.x branch fixing numerous smaller bugs. For a changelog, see the git log here: https://git.savannah.nongnu.org/cgit/lwip.git/log/?h=STABLE-2_1_3_RELEASE As always, all users are strongly suggested to upgrade! Contrib has still not been changed since 2.1.0, so 'contrib-2.1.0.zip' is still valid. Thanks for all contributions! Simon
Lwip之SNMP实现.pdf
01-10
Lwip之SNMP实现.pdf
lwIP 2.1.1
11-13
2018年11月8日最新更新：lwIP 2.1.1 lwIP 2.1.1 released posted by goldsimon, Thu 08 Nov 2018 09:34:54 PM UTC - 0 replies lwIP 2.1.1 is now available from the lwIP download area or via git (using the STABLE-2_1_1_RELEASE tag). This is a smaller bugfix-only release. Contrib has not been changed since 2.1.0. For a list of the 11 bugs fixed, see CHANGELOG. Please note that all users of 2.1.0 should upgrade (should be a matter of copying the new files only, no changes required). Thanks for all contributions! Simon
lwip数据接收发送过程.pdf
01-10
lwip数据接收发送过程.pdf
lwip-rtos-ping-socket
最新发布
05-01
lwip_rtos_ping_socket
lwip-rtos-netconn
05-01
lwip_rtos_netconn
LWIP v2.1.0内存管理之相关宏之间的关系
白小白
10-15 1017
一）、LWIP内存管理之相关宏之间的关系： 工作比较忙，经常加班搬砖，所以自己写东西的时间就比较少了，而且由于自己是边学边写，自己看源码内容加上消化要一周，然后由于想把文档写好点，所以写东西也要一周，真是太慢了，不过慢不要紧，只要不停下，总有一天能把他写完。那谁不是说时间就像乳沟，挤挤总是有的(我是一个瘦瘦的男生，他么的怎么挤也没有啊)。。。。 总的来说, LWIP 的动态内存管理机制可以有以...
Lwip dns动态申请内存
05-16
LwIP 是一个轻量级的 TCP/IP 协议栈，它可以运行在嵌入式系统上。在 LwIP 中，DNS 动态申请内存的方式取决于 LwIP 的内存管理模式。LwIP 内置了两种内存管理模式：堆式和池式。 在堆式内存管理模式下，LwIP 使用标准的 C 库函数 malloc() 和 free() 来申请和释放内存。在这种模式下，LwIP 的 DNS 模块会通过调用 malloc() 函数来分配内存。 在池式内存管理模式下，LwIP 会为每个协议模块预先分配一块固定大小的内存池。在这种模式下，DNS 模块会从内存池中获取内存。 在 LwIP 中开启 DNS 支持的方法如下： 1. 在 LwIP 的配置文件中打开 DNS 支持选项。 2. 通过调用 lwip_dns_init() 函数初始化 DNS 模块。 3. 在需要使用 DNS 的地方调用 lwip_gethostbyname() 函数。 需要注意的是，LwIP 的内存管理模式会对 DNS 模块的性能和内存占用产生影响。在使用过程中需要根据具体情况进行选择。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值