内存池分配器

内存池分配器 的协作图:

结构体
struct	xwmm_mempool
	内存池 更多...
struct	xwmm_mempool_i_allocator
	interface：分配器 更多...
struct	xwmm_mempool_objcache
	对象缓存 更多...
struct	xwmm_mempool_page
	内存页 更多...
struct	xwmm_mempool_page_odrbtree
	阶红黑树 更多...
struct	xwmm_mempool_page_allocator
	页分配器 更多...

宏定义
#define	XWMM_MEMPOOL_PAGE_SIZE   (4096U)
#define	XWMM_MEMPOOL_OC_8_PAGE_ODR   (0U)
#define	XWMM_MEMPOOL_OC_16_PAGE_ODR   (0U)
#define	XWMM_MEMPOOL_OC_32_PAGE_ODR   (0U)
#define	XWMM_MEMPOOL_OC_64_PAGE_ODR   (0U)
#define	XWMM_MEMPOOL_OC_96_PAGE_ODR   (1U)
#define	XWMM_MEMPOOL_OC_128_PAGE_ODR   (0U)
#define	XWMM_MEMPOOL_OC_160_PAGE_ODR   (0U)
#define	XWMM_MEMPOOL_OC_192_PAGE_ODR   (0U)
#define	XWMM_MEMPOOL_OC_256_PAGE_ODR   (0U)
#define	XWMM_MEMPOOL_OC_320_PAGE_ODR   (1U)
#define	XWMM_MEMPOOL_OC_384_PAGE_ODR   (1U)
#define	XWMM_MEMPOOL_OC_512_PAGE_ODR   (1U)
#define	XWMM_MEMPOOL_OC_768_PAGE_ODR   (0U)
#define	XWMM_MEMPOOL_OC_1024_PAGE_ODR   (0U)
#define	XWMM_MEMPOOL_OC_2048_PAGE_ODR   (1U)
#define	XWMM_MEMPOOL_RAWOBJ_DEF(name, pgodr)
	定义内存池结构体的RAW内存空间，用于初始化内存池结构体
#define	XWMM_MEMPOOL_PAGE_ORDER_CMB   (XWSQ_MAX)
#define	XWMM_MEMPOOL_PAGE_MAPPING_FREE   (0U)
#define	XWMM_MEMPOOL_PAGE_MAPPING_INVAILD   (XWPTR_MAX)

函数
xwer_t	xwmm_mempool_init (struct xwmm_mempool *mp, const char *name, xwptr_t origin, xwsz_t size, xwsz_t pgodr, xwsz_t pre, void **membuf)
	XWMM API：初始化内存池
xwer_t	xwmm_mempool_malloc (struct xwmm_mempool *mp, xwsz_t size, void **membuf)
	XWMM API：从内存池中申请内存
xwer_t	xwmm_mempool_free (struct xwmm_mempool *mp, void *mem)
	XWMM API：释放内存
xwer_t	xwmm_mempool_realloc (struct xwmm_mempool *mp, xwsz_t size, void **membuf)
	XWMM API：调整内存大小
xwer_t	xwmm_mempool_memalign (struct xwmm_mempool *mp, xwsz_t alignment, xwsz_t size, void **membuf)
	XWMM API：从内存池中申请对齐的内存
xwer_t	xwmm_mempool_objcache_init (struct xwmm_mempool_objcache *oc, struct xwmm_mempool_page_allocator *pa, const char *name, xwsz_t objsize, xwsz_t alignment, xwsq_t pg_order, ctor_f ctor, dtor_f dtor)
	XWMM API：初始化对象缓存
xwer_t	xwmm_mempool_objcache_alloc (struct xwmm_mempool_objcache *oc, void **objbuf)
	XWMM API：从对象缓存中申请一个对象
xwer_t	xwmm_mempool_objcache_free (struct xwmm_mempool_objcache *oc, void *obj)
	XWMM API：释放对象到对象缓存中
xwer_t	xwmm_mempool_objcache_reserve (struct xwmm_mempool_objcache *oc, xwsz_t reserved)
	XWMM API：预留对象到对象缓存中
xwer_t	xwmm_mempool_objcache_get_capacity (struct xwmm_mempool_objcache *oc, xwsz_t *capacity)
	XWMM API：获取对象缓存的容量
xwer_t	xwmm_mempool_page_find (struct xwmm_mempool_page_allocator *pa, void *mem, struct xwmm_mempool_page **pgbuf)
	依据内存地址查找页
xwer_t	xwmm_mempool_page_allocator_init (struct xwmm_mempool_page_allocator *pa, const char *name, xwptr_t origin, xwsz_t size, xwsz_t pgsize, struct xwmm_mempool_page_odrbtree *odrbtree, struct xwmm_mempool_page *pgarray)
	XWMM API：初始化页分配器
xwer_t	xwmm_mempool_page_allocate (struct xwmm_mempool_page_allocator *pa, xwsq_t order, struct xwmm_mempool_page **pgbuf)
	XWMM API：申请一页内存
xwer_t	xwmm_mempool_page_free (struct xwmm_mempool_page_allocator *pa, struct xwmm_mempool_page *pg)
	XWMM API：释放一页内存

详细描述

内存池是结合了内存切片分配器与伙伴算法分配器的算法。内存管理的基本单位为页， 一页内存为4096字节，页内存使用伙伴算法分配器管理。 内存池还使用对象缓存算法建立各种小尺寸的块：8字节、16字节、32字节、 64字节、96字节、128字节、160字节、192字节、256字节、320字节、384字节、 512字节、768字节、1024字节、2048字节。 当申请内存大于2048字节，直接分配页内存；当申请的内存小于等于2048字节， 就从尺寸最合适的对象缓存分配器中分配一块内存。

• 优点：
  • 支持释放操作；
  • 支持大小不固定的内存申请操作；
  • 反复申请与释放不会造成内存碎片；
  • 小内存块不会浪费过多的内存。
• 缺点：
  • 代码复杂；
  • 申请与释放操作的所需要的时间不稳定。
• 适用性：外接尺寸较大的SRAM或SDRAM的内存管理，C++和Lua虚拟机的对象池。
• 上下文的安全性：在任何上下文（中断、中断底半部、线程）都是安全的。

宏定义说明

XWMM_MEMPOOL_OC_1024_PAGE_ODR

#define XWMM_MEMPOOL_OC_1024_PAGE_ODR   (0U)

1024字节分配器所使用的页的阶数

在文件 allocator.h 第 65 行定义.

XWMM_MEMPOOL_OC_128_PAGE_ODR

#define XWMM_MEMPOOL_OC_128_PAGE_ODR   (0U)

128字节分配器所使用的页的阶数

在文件 allocator.h 第 57 行定义.

XWMM_MEMPOOL_OC_160_PAGE_ODR

#define XWMM_MEMPOOL_OC_160_PAGE_ODR   (0U)

160字节分配器所使用的页的阶数

在文件 allocator.h 第 58 行定义.

XWMM_MEMPOOL_OC_16_PAGE_ODR

#define XWMM_MEMPOOL_OC_16_PAGE_ODR   (0U)

16字节分配器所使用的页的阶数

在文件 allocator.h 第 53 行定义.

XWMM_MEMPOOL_OC_192_PAGE_ODR

#define XWMM_MEMPOOL_OC_192_PAGE_ODR   (0U)

192字节分配器所使用的页的阶数

在文件 allocator.h 第 59 行定义.

XWMM_MEMPOOL_OC_2048_PAGE_ODR

#define XWMM_MEMPOOL_OC_2048_PAGE_ODR   (1U)

2048字节分配器所使用的页的阶数

在文件 allocator.h 第 66 行定义.

XWMM_MEMPOOL_OC_256_PAGE_ODR

#define XWMM_MEMPOOL_OC_256_PAGE_ODR   (0U)

256字节分配器所使用的页的阶数

在文件 allocator.h 第 60 行定义.

XWMM_MEMPOOL_OC_320_PAGE_ODR

#define XWMM_MEMPOOL_OC_320_PAGE_ODR   (1U)

320字节分配器所使用的页的阶数

在文件 allocator.h 第 61 行定义.

XWMM_MEMPOOL_OC_32_PAGE_ODR

#define XWMM_MEMPOOL_OC_32_PAGE_ODR   (0U)

32字节分配器所使用的页的阶数

在文件 allocator.h 第 54 行定义.

XWMM_MEMPOOL_OC_384_PAGE_ODR

#define XWMM_MEMPOOL_OC_384_PAGE_ODR   (1U)

384字节分配器所使用的页的阶数

在文件 allocator.h 第 62 行定义.

XWMM_MEMPOOL_OC_512_PAGE_ODR

#define XWMM_MEMPOOL_OC_512_PAGE_ODR   (1U)

512字节分配器所使用的页的阶数

在文件 allocator.h 第 63 行定义.

XWMM_MEMPOOL_OC_64_PAGE_ODR

#define XWMM_MEMPOOL_OC_64_PAGE_ODR   (0U)

64字节分配器所使用的页的阶数

在文件 allocator.h 第 55 行定义.

XWMM_MEMPOOL_OC_768_PAGE_ODR

#define XWMM_MEMPOOL_OC_768_PAGE_ODR   (0U)

768字节分配器所使用的页的阶数

在文件 allocator.h 第 64 行定义.

XWMM_MEMPOOL_OC_8_PAGE_ODR

#define XWMM_MEMPOOL_OC_8_PAGE_ODR   (0U)

8字节分配器所使用的页的阶数

在文件 allocator.h 第 52 行定义.

XWMM_MEMPOOL_OC_96_PAGE_ODR

#define XWMM_MEMPOOL_OC_96_PAGE_ODR   (1U)

96字节分配器所使用的页的阶数

在文件 allocator.h 第 56 行定义.

XWMM_MEMPOOL_PAGE_MAPPING_FREE

#define XWMM_MEMPOOL_PAGE_MAPPING_FREE   (0U)

在文件 page.h 第 31 行定义.

XWMM_MEMPOOL_PAGE_MAPPING_INVAILD

#define XWMM_MEMPOOL_PAGE_MAPPING_INVAILD   (XWPTR_MAX)

在文件 page.h 第 32 行定义.

XWMM_MEMPOOL_PAGE_ORDER_CMB

#define XWMM_MEMPOOL_PAGE_ORDER_CMB   (XWSQ_MAX)

在文件 page.h 第 30 行定义.

XWMM_MEMPOOL_PAGE_SIZE

#define XWMM_MEMPOOL_PAGE_SIZE   (4096U)

注解

• 页的最小单位是 XWMM_MEMPOOL_PAGE_SIZE
• 页的阶数n是指，以2的n次方的形式表示的单位页的数量。n阶页的大小是(4K * pow(2, n))。 每页内存的字节数

在文件 allocator.h 第 51 行定义.

XWMM_MEMPOOL_RAWOBJ_DEF

#define XWMM_MEMPOOL_RAWOBJ_DEF	(		name,
			pgodr
	)

值:

        xwu8_t name[sizeof(struct xwmm_mempool) + \
                    sizeof(struct xwmm_mempool_page_odrbtree[(pgodr) + 1U]) + \
                    sizeof(struct xwmm_mempool_page[1U << (pgodr)])]

定义内存池结构体的RAW内存空间，用于初始化内存池结构体

参数

[in]	name	内存数组名
[in]	pgodr	页的数量，以2的pgodr次方形式表示

在文件 allocator.h 第 78 行定义.

函数说明

xwmm_mempool_free()

xwer_t xwmm_mempool_free	(	struct xwmm_mempool *	mp,
		void *	mem
	)

XWMM API：释放内存

参数

[in]	mp	内存池的指针
[in]	mem	内存的首地址

返回

错误码

返回值

XWOK	没有错误
-EFAULT	空指针
-EALREADY	页内存已释放
-ERANGE	内存地址不在内存池的范围内

注解

• 同步/异步：同步
• 上下文：中断、中断底半部、线程
• 重入性：可重入

此函数向内存池释放内存。内存必须是此前申请的，如果 mem 是错误的地址或之前被释放过， 将产生未定义的错误。 mem 可以为 NULL ，此函数什么也不做，并且返回错误码 XWOK 。

<No error

在文件 allocator.c 第 342 行定义.

{
        interface xwmm_mempool_i_allocator * ia;
        struct xwmm_mempool_page * pg;
        xwer_t rc;
 
        XWOS_VALIDATE((mp), "nullptr", -EFAULT);
 
        if (NULL == mem) {
                rc = XWOK;
                goto do_nothing;
        }
 
        rc = xwmm_mempool_page_find(&mp->pa, mem, &pg);
        if (rc < 0) {
                goto err_pg_find;
        }
 
        switch (pg->data.value) {
        case 8:
                ia = (void *)&mp->oc_8;
                break;
        case 16:
                ia = (void *)&mp->oc_16;
                break;
        case 32:
                ia = (void *)&mp->oc_32;
                break;
        case 64:
                ia = (void *)&mp->oc_64;
                break;
        case 96:
                ia = (void *)&mp->oc_96;
                break;
        case 128:
                ia = (void *)&mp->oc_128;
                break;
        case 160:
                ia = (void *)&mp->oc_160;
                break;
        case 192:
                ia = (void *)&mp->oc_192;
                break;
        case 256:
                ia = (void *)&mp->oc_256;
                break;
        case 320:
                ia = (void *)&mp->oc_320;
                break;
        case 384:
                ia = (void *)&mp->oc_384;
                break;
        case 512:
                ia = (void *)&mp->oc_512;
                break;
        case 768:
                ia = (void *)&mp->oc_768;
                break;
        case 1024:
                ia = (void *)&mp->oc_1024;
                break;
        case 2048:
                ia = (void *)&mp->oc_2048;
                break;
        default:
                ia = (void *)&mp->pa;
                break;
        }
        rc = ia->free(ia, mem);
 
err_pg_find:
do_nothing:
        return rc;
}

函数调用图:

这是这个函数的调用关系图:

xwmm_mempool_init()

xwer_t xwmm_mempool_init	(	struct xwmm_mempool *	mp,
		const char *	name,
		xwptr_t	origin,
		xwsz_t	size,
		xwsz_t	pgodr,
		xwsz_t	pre,
		void **	membuf
	)

XWMM API：初始化内存池

参数

[in]	mp	内存池的指针
[in]	name	名字
[in]	origin	内存区域的起始地址
[in]	size	内存区域的总大小
[in]	pgodr	页的数量，以2的pgodr次方形式表示
[in]	pre	预申请的内存的大小
[out]	membuf	指向缓冲区的指针，通过此缓冲区返回预申请内存的首地址

返回

错误码

返回值

XWOK	没有错误
-EFAULT	空指针
-E2SMALL	内存区域太小
-ESIZE	内存区域大小size与pgodr指明的页数量不匹配

注解

• 同步/异步：同步
• 上下文：中断、中断底半部、线程
• 重入性：不可重入

• 将首地址为 origin ，大小为 size 的内存初始化为内存池：
  • 页的数量用 pgodr 表示，只能是2的n次方，即 2, 4, 8, 16, 32, 64, 128, ... ， 对应的pgodr分别为 1, 2, 3, 4, 5, 6, 7, ... ；
  • 内存区域大小必须满足关系： size == (XWMM_MEMPOOL_PAGE_SIZE * (1 << pgodr)) 。
• 如果在内存区域开始的地方，已经由编译器预先分配了一片内存， 用户只想将剩下的内存用作内存池，则需要将编译器预先分配的内存在内存池中申请出来， 防止内存发生重叠。参数 pre 以及 membuf 就是作为此用途而设计的。 membuf 可以为 NULL ，表示不需要返回编译器预先申请内存的首地址。

< 每页内存的字节数

<Size error

< 每页内存的字节数

< 每页内存的字节数

<No error

在文件 allocator.c 第 200 行定义.

{
        xwer_t rc;
        struct xwmm_mempool_page_odrbtree * odrbtrees;
        xwsz_t odrbtrees_size;
        struct xwmm_mempool_page * pages;
        xwsz_t pages_nr;
        xwsz_t pages_size;
        void * mem;
 
        XWOS_VALIDATE((mp), "nullptr", -EFAULT);
 
        pages_nr = size / XWMM_MEMPOOL_PAGE_SIZE;
        if (pages_nr != (1U << pgodr)) {
                rc = - ESIZE;
                goto err_size;
        }
 
        odrbtrees = (struct xwmm_mempool_page_odrbtree *)&mp[(xwsz_t)1];
        pages = (struct xwmm_mempool_page *)&odrbtrees[pgodr + (xwsz_t)1];
        odrbtrees_size = sizeof(struct xwmm_mempool_page_odrbtree) *
                         (pgodr + (xwsz_t)1);
        pages_size = sizeof(struct xwmm_mempool_page) << pgodr;
        rc = xwmm_mempool_construct(mp, name, origin, size, odrbtrees, pages);
        if (rc < 0) {
                goto err_mempool_construct;
        }
 
        if (pre > (xwsz_t)0) {
                rc = xwmm_mempool_malloc(mp, pre, &mem);
                if (rc < 0) {
                        goto err_mempool_prealloc;
                }
                if (NULL != membuf) {
                        *membuf = mem;
                }
        } else if ((xwptr_t)mp == origin) {
                xwsz_t mpsz = sizeof(struct xwmm_mempool) + odrbtrees_size + pages_size;
                if (mpsz < XWMM_MEMPOOL_PAGE_SIZE) {
                        mpsz = XWMM_MEMPOOL_PAGE_SIZE;
                }
                rc = xwmm_mempool_malloc(mp, mpsz, &mem);
                if (rc < 0) {
                        goto err_mempool_prealloc;
                }
                if (NULL != membuf) {
                        *membuf = mem;
                }
        } else {}
        return XWOK;
 
err_mempool_prealloc:
err_mempool_construct:
err_size:
        return rc;
}

函数调用图:

xwmm_mempool_malloc()

xwer_t xwmm_mempool_malloc	(	struct xwmm_mempool *	mp,
		xwsz_t	size,
		void **	membuf
	)

XWMM API：从内存池中申请内存

参数

[in]	mp	内存池的指针
[in]	size	申请的大小
[out]	membuf	指向缓冲区的指针，通过此缓冲区返回申请到的内存的首地址

返回

错误码

返回值

XWOK	没有错误
-EFAULT	空指针
-ENOMEM	内存不足

注解

• 同步/异步：同步
• 上下文：中断、中断底半部、线程
• 重入性：可重入

• 此函数向内存池申请大小为 size 的内存：
  • 若申请成功，通过 *membuf 返回申请到的内存地址 ，返回错误码为 XWOK ；
  • 若申请失败，通过 *membuf 返回 NULL ，返回值为负的错误码。
• 内存不会被初始化；
• 当 size 为 0 ， 通过 *membuf 返回 NULL ，返回错误码为 XWOK ；

<No error

< 内存管理对齐的字节数

< 内存管理对齐的字节数

在文件 allocator.c 第 260 行定义.

{
        interface xwmm_mempool_i_allocator * ia;
        xwssq_t odr;
        xwer_t rc;
 
        XWOS_VALIDATE((mp), "nullptr", -EFAULT);
        XWOS_VALIDATE((membuf), "nullptr", -EFAULT);
 
        if ((xwsz_t)0 == size) {
                rc = XWOK;
                *membuf = NULL;
        } else {
                size = XWBOP_ALIGN(size, (xwsz_t)XWMM_ALIGNMENT);
                odr = xwbop_fls(xwsz_t, size);
                while (((xwsz_t)1 << (xwsz_t)odr) < size) {
                        odr++;
                }
                // cppcheck-suppress [misra-c2012-17.8]
                size = (xwsz_t)1 << (xwsz_t)odr;
 
                switch (size) {
                case 8:
                        ia = (void *)&mp->oc_8;
                        break;
                case 16:
                        ia = (void *)&mp->oc_16;
                        break;
                case 32:
                        ia = (void *)&mp->oc_32;
                        break;
                case 64:
                        ia = (void *)&mp->oc_64;
                        break;
                case 128:
                        if (size <= (xwsz_t)96) {
                                ia = (void *)&mp->oc_96;
                        } else {
                                ia = (void *)&mp->oc_128;
                        }
                        break;
                case 256:
                        if (size <= (xwsz_t)160) {
                                ia = (void *)&mp->oc_160;
                        } else if (size <= (xwsz_t)192) {
                                ia = (void *)&mp->oc_192;
                        } else {
                                ia = (void *)&mp->oc_256;
                        }
                        break;
                case 512:
                        if (size <= (xwsz_t)320) {
                                ia = (void *)&mp->oc_320;
                        } else if (size <= (xwsz_t)384) {
                                ia = (void *)&mp->oc_384;
                        } else {
                                ia = (void *)&mp->oc_512;
                        }
                        break;
                case 1024:
                        if (size <= (xwsz_t)768) {
                                ia = (void *)&mp->oc_768;
                        } else {
                                ia = (void *)&mp->oc_1024;
                        }
                        break;
                case 2048:
                        ia = (void *)&mp->oc_2048;
                        break;
                default:
                        ia = (void *)&mp->pa;
                        break;
                }
                rc = ia->malloc(ia, size, membuf);
                if (rc < 0) {
                        *membuf = NULL;
                }
        }
        return rc;
}

这是这个函数的调用关系图:

xwmm_mempool_memalign()

xwer_t xwmm_mempool_memalign	(	struct xwmm_mempool *	mp,
		xwsz_t	alignment,
		xwsz_t	size,
		void **	membuf
	)

XWMM API：从内存池中申请对齐的内存

参数

[in]	mp	内存池的指针
[in]	alignment	内存的起始地址对齐的字节数，只能是2的n次方
[in]	size	申请的大小
[out]	membuf	指向缓冲区的指针，通过此缓冲区返回申请到的内存的首地址

返回

错误码

返回值

XWOK	没有错误
-EFAULT	空指针
-ENOMEM	内存不足

注解

• 同步/异步：同步
• 上下文：中断、中断底半部、线程
• 重入性：可重入

• 此API类似于C标准中的 memalign() 函数：
  • alignment 如果比 XWMM_ALIGNMENT 小，会被扩大为 XWMM_ALIGNMENT ：
  • alignment 只能是2的n次方：
  • 若size小于 alignment ， size 会被扩大为 alignment ，
  • 若size大于 alignment ， size 会向上对齐到2的n次方，此时也一定为 alignment 的整数倍。
• 申请内存失败时，此函数不会修改 *membuf 的值。

< 内存管理对齐的字节数

< 内存管理对齐的字节数

<No error

在文件 allocator.c 第 467 行定义.

{
        interface xwmm_mempool_i_allocator * ia;
        xwssq_t p2;
        xwer_t rc;
 
        XWOS_VALIDATE((mp), "nullptr", -EFAULT);
        XWOS_VALIDATE((membuf), "nullptr", -EFAULT);
 
        if (alignment < XWMM_ALIGNMENT) {
                alignment = XWMM_ALIGNMENT;
        }
        p2 = xwbop_fls(xwsz_t, alignment);
        if (((xwsz_t)1 << (xwsz_t)p2) != alignment) {
                rc = -EINVAL;
                goto err_notp2;
        }
        if ((xwsz_t)0 == size) {
                rc = XWOK;
                *membuf = NULL;
                goto nothing;
        }
        if (size <= alignment) {
                size = alignment;
        } else {
                p2 = xwbop_fls(xwsz_t, size);
                while (((xwsz_t)1 << (xwsz_t)p2) < size) {
                        p2++;
                }
                size = (xwsz_t)1 << (xwsz_t)p2;
        }
 
        switch (size) {
        case 8:
                ia = (void *)&mp->oc_8;
                break;
        case 16:
                ia = (void *)&mp->oc_16;
                break;
        case 32:
                ia = (void *)&mp->oc_32;
                break;
        case 64:
                ia = (void *)&mp->oc_64;
                break;
        case 128:
                ia = (void *)&mp->oc_128;
                break;
        case 256:
                ia = (void *)&mp->oc_256;
                break;
        case 512:
                ia = (void *)&mp->oc_512;
                break;
        case 1024:
                ia = (void *)&mp->oc_1024;
                break;
        case 2048:
                ia = (void *)&mp->oc_2048;
                break;
        default:
                ia = (void *)&mp->pa;
                break;
        }
        rc = ia->malloc(ia, size, membuf);
 
nothing:
err_notp2:
        return rc;
}

xwmm_mempool_objcache_alloc()

xwer_t xwmm_mempool_objcache_alloc	(	struct xwmm_mempool_objcache *	oc,
		void **	objbuf
	)

XWMM API：从对象缓存中申请一个对象

参数

[in]	oc	对象缓存的指针
[out]	objbuf	指向缓冲区的指针，此缓冲区被用于返回对象的指针

返回

错误码

返回值

XWOK	没有错误
-ENOMEM	内存不足

< 报告BUG

< 当条件x成立时报告BUG

< 报告BUG

< 当条件x成立时报告BUG

<No error

在文件 objcache.c 第 263 行定义.

{
        struct xwmm_mempool_page * pg;
        xwlfq_t * obj;
        xwreg_t flag;
        xwer_t rc;
 
        rc = xwmm_mempool_objcache_page_get(oc, &pg);
        if (rc < 0) {
                goto err_page_get;
        }
 
        xwaop_sub(xwsz_t, &oc->idleness, 1, NULL, NULL);
        obj = xwlib_lfq_pop(&pg->attr.objcache.objhead);
        XWOS_BUG_ON(NULL == obj);
        *obj = oc->backup;
        *objbuf = (void *)obj;
 
        xwos_sqlk_wr_lock_cpuirqsv(&oc->page_list.lock, &flag);
        XWOS_BUG_ON(pg->attr.objcache.refcnt >= oc->pg_objnr);
        pg->attr.objcache.refcnt++;
        xwlib_bclst_del_init(&pg->attr.objcache.node);
        if (pg->attr.objcache.refcnt == oc->pg_objnr) {
                xwlib_bclst_add_tail(&oc->page_list.full, &pg->attr.objcache.node);
        } else {
                xwlib_bclst_add_head(&oc->page_list.available, &pg->attr.objcache.node);
        }
        xwos_sqlk_wr_unlock_cpuirqrs(&oc->page_list.lock, flag);
 
        return XWOK;
 
err_page_get:
        return rc;
}

函数调用图:

这是这个函数的调用关系图:

xwmm_mempool_objcache_free()

xwer_t xwmm_mempool_objcache_free	(	struct xwmm_mempool_objcache *	oc,
		void *	obj
	)

XWMM API：释放对象到对象缓存中

参数

[in]	oc	对象缓存的指针
[in]	obj	对象的指针

返回

错误码

返回值

XWOK	没有错误
-ERANGE	内存地址不在内存池的范围内

<No error

在文件 objcache.c 第 299 行定义.

{
        atomic_xwlfq_t * lfq;
        struct xwmm_mempool_page * pg;
        xwsz_t reserved;
        xwsz_t idleness;
        xwptr_t offset;
        xwptr_t origin;
        xwer_t rc;
 
        rc = xwmm_mempool_page_find(oc->pa, obj, &pg);
        if (rc < 0) {
                goto err_pg_find;
        }
 
        offset = ((xwptr_t)obj - pg->mapping) % oc->objsize;
        origin = (xwptr_t)obj - offset;
        obj = (void *)origin;
 
        if (NULL != oc->dtor) {
                oc->dtor(obj);
        }
 
        lfq = (atomic_xwlfq_t *)obj;
        xwlib_lfq_push(&pg->attr.objcache.objhead, lfq);
 
        xwmm_mempool_objcache_page_put(oc, pg);
        xwaop_add(xwsz_t, &oc->idleness, 1, &idleness, NULL);
        reserved = xwaop_load(xwsz_t, &oc->reserved, xwaop_mo_relaxed);
 
        if ((reserved + oc->pg_objnr) <= idleness) {
                xwsz_t nr;
 
                nr = (idleness - reserved) / oc->pg_objnr;
                // cppcheck-suppress [misra-c2012-17.7]
                xwmm_mempool_objcache_free_idle_page(oc, nr);
        }
 
        return XWOK;
 
err_pg_find:
        return rc;
}

函数调用图:

这是这个函数的调用关系图:

xwmm_mempool_objcache_get_capacity()

xwer_t xwmm_mempool_objcache_get_capacity	(	struct xwmm_mempool_objcache *	oc,
		xwsz_t *	capacity
	)

XWMM API：获取对象缓存的容量

参数

[in]	oc	对象缓存的指针
[out]	capacity	指向缓冲区的指针，通过此缓冲区返回对象缓存的容量

返回

错误码

返回值

XWOK

没有错误

<No error

在文件 objcache.c 第 383 行定义.

{
        *capacity = xwaop_load(xwsz_t, &oc->capacity, xwaop_mo_relaxed);
        return XWOK;
}

xwmm_mempool_objcache_init()

xwer_t xwmm_mempool_objcache_init	(	struct xwmm_mempool_objcache *	oc,
		struct xwmm_mempool_page_allocator *	pa,
		const char *	name,
		xwsz_t	objsize,
		xwsz_t	alignment,
		xwsq_t	pg_order,
		ctor_f	ctor,
		dtor_f	dtor
	)

XWMM API：初始化对象缓存

参数

[in]	oc	对象缓存的指针
[in]	pa	页分配器的指针
[in]	name	名字
[in]	objsize	对象的大小
[in]	alignment	对齐的大小
[in]	pg_order	每次预先申请页的数量的阶，几阶就是2的几次方
[in]	ctor	构造函数
[in]	dtor	析构函数

返回

错误码

返回值

XWOK	没有错误
-EALIGN	内存区域没有对齐

< 内存管理对齐的字节数

< 内存管理对齐的字节数

<No error

在文件 objcache.c 第 54 行定义.

{
        xwsz_t nr;
        xwsz_t pgsize;
 
/*
 * ----------------------------
 * | struct xwmm_mempool_page |
 * -----------------------------------------------------------------------------
 * |  attr.objcache.objhead   |->| obj | a | obj | a | obj | a | ...
 * |--------------------------|-------------------------------------------------
 * | ...                      |        |   ^     |   ^     |   ^
 * |--------------------------|        |___|     |___|     |___|
 * obj: object
 * a: alignment area
 */
 
        alignment = XWBOP_ALIGN(alignment, (xwsz_t)XWMM_ALIGNMENT);
        objsize = XWBOP_ALIGN(objsize, (xwsz_t)alignment);
        if (NULL != ctor) {
                xwu8_t obj[objsize];
                ctor((void *)obj);
                oc->backup = *((xwptr_t *)obj);
        } else {
                oc->backup = 0;
        }
 
        pgsize = pa->pgsize << pg_order;
        nr = pgsize / objsize;
 
        oc->name = name;
        oc->pa = pa;
        oc->objsize = objsize;
        oc->alignment = alignment;
        oc->pg_order = pg_order;
        oc->pg_objnr = nr;
        oc->ctor = ctor;
        oc->dtor = dtor;
        oc->capacity = 0;
        oc->idleness = 0;
        oc->reserved = 0;
        xwlib_bclst_init_head(&oc->page_list.full);
        xwlib_bclst_init_head(&oc->page_list.available);
        xwlib_bclst_init_head(&oc->page_list.idle);
        xwos_sqlk_init(&oc->page_list.lock);
        oc->i_a.malloc = xwmm_mempool_objcache_i_a_malloc;
        oc->i_a.free = xwmm_mempool_objcache_i_a_free;
 
        return XWOK;
}

函数调用图:

这是这个函数的调用关系图:

xwmm_mempool_objcache_reserve()

xwer_t xwmm_mempool_objcache_reserve	(	struct xwmm_mempool_objcache *	oc,
		xwsz_t	reserved
	)

XWMM API：预留对象到对象缓存中

参数

[in]	oc	对象缓存的指针
[in]	reserved	预留的数量

返回

错误码

返回值

XWOK	没有错误
-ENOMEM	内存不足

<No error

在文件 objcache.c 第 344 行定义.

{
        struct xwmm_mempool_page * pg;
        xwsz_t capacity;
        xwsz_t idleness;
        xwreg_t flag;
        xwer_t rc;
 
        reserved = XWBOP_DIV_ROUND_UP(reserved, oc->pg_objnr);
        xwaop_write(xwsz_t, &oc->reserved, reserved, NULL);
        capacity = xwaop_load(xwsz_t, &oc->capacity, xwaop_mo_relaxed);
        idleness = xwaop_load(xwsz_t, &oc->idleness, xwaop_mo_relaxed);
        if (capacity < reserved) {
                rc = xwmm_mempool_page_allocate(oc->pa, oc->pg_order, &pg);
                if (rc < 0) {
                        goto err_pg_alloc;
                }
                xwaop_add(xwsz_t, &oc->capacity, oc->pg_objnr, NULL, NULL);
                xwaop_add(xwsz_t, &oc->idleness, oc->pg_objnr, NULL, NULL);
                xwmm_mempool_objcache_page_init(oc, pg);
                xwos_sqlk_wr_lock_cpuirqsv(&oc->page_list.lock, &flag);
                xwlib_bclst_add_tail(&oc->page_list.idle, &pg->attr.objcache.node);
                xwos_sqlk_wr_unlock_cpuirqrs(&oc->page_list.lock, flag);
        } else if ((reserved + oc->pg_objnr) < idleness) {
                xwsz_t nr;
 
                nr = (idleness - reserved) / oc->pg_objnr;
                // cppcheck-suppress [misra-c2012-17.7]
                xwmm_mempool_objcache_free_idle_page(oc, nr);
        } else {
        }
        return XWOK;
 
err_pg_alloc:
        return rc;
}

函数调用图:

xwmm_mempool_page_allocate()

xwer_t xwmm_mempool_page_allocate	(	struct xwmm_mempool_page_allocator *	pa,
		xwsq_t	order,
		struct xwmm_mempool_page **	pgbuf
	)

XWMM API：申请一页内存

参数

[in]	pa	页分配器的指针
[in]	order	页数量的阶，页内存大小： ((1 << order) * pa->pgsize)
[out]	pgbuf	指向缓冲区的指针，通过此缓冲区返回申请到的页控制块的指针

返回

错误码

返回值

XWOK	没有错误
-ENOMEM	内存不足

<No error

在文件 page.c 第 159 行定义.

{
        xwsq_t odr;
        struct xwmm_mempool_page_odrbtree * ot;
        struct xwmm_mempool_page * pg;
        xwptr_t origin;
        xwer_t rc;
 
        rc = -ENOMEM;
        for (odr = order; odr <= pa->max_order; odr++) {
                ot = &pa->odrbtree[odr];
                pg = xwmm_mempool_page_odrbtree_choose(ot);
                if (NULL != pg) {
                        xwmm_mempool_page_divide_page(pa, pg, order, ot);
                        origin = pa->zone.origin + (pg->attr.free.seq * pa->pgsize);
                        pg->mapping = origin;
                        *pgbuf = pg;
                        rc = XWOK;
                        break;
                }
        }
        return rc;
}

函数调用图:

这是这个函数的调用关系图:

xwmm_mempool_page_allocator_init()

xwer_t xwmm_mempool_page_allocator_init	(	struct xwmm_mempool_page_allocator *	pa,
		const char *	name,
		xwptr_t	origin,
		xwsz_t	size,
		xwsz_t	pgsize,
		struct xwmm_mempool_page_odrbtree *	odrbtree,
		struct xwmm_mempool_page *	pgarray
	)

XWMM API：初始化页分配器

参数

[in]	pa	页分配器的指针
[in]	name	名字
[in]	origin	内存区域的起始地址
[in]	size	内存区域的总大小
[in]	pgsize	单位页的大小
[in]	odrbtree	阶红黑树数组的指针
[in]	pgarray	页控制块数组的指针

返回

错误码

返回值

XWOK	没有错误
-E2SMALL	内存区域太小
-EALIGN	内存区域没有对齐

<Too small

< 内存管理对齐的字节数

< 内存管理未对齐掩码

<Not aligned

<Not aligned

<No error

在文件 page.c 第 86 行定义.

{
        xwsz_t i;
        xwssq_t order;
        xwsz_t nr;
        xwer_t rc;
 
        if (size < pgsize) {
                rc = -E2SMALL;
                goto err_mem2small;
        }
        // cppcheck-suppress [misra-c2012-10.8]
        if ((xwsz_t)0 != (pgsize & (xwsz_t)XWMM_UNALIGNED_MASK)) {
                rc = -EALIGN;
                goto err_aligned;
        }
        nr = size / pgsize;
        order = xwbop_fls(xwsz_t, nr);
        if ((order < 0) || (nr & ((1U << (xwsz_t)order) - 1U))) {
                rc = -EALIGN;
                goto err_aligned;
        }
 
        pa->zone.origin = origin;
        pa->zone.size = size;
        pa->name = name;
        pa->pgsize = pgsize;
        pa->max_order = (xwsq_t)order;
        pa->odrbtree = odrbtree;
        pa->pgarray = pgarray;
 
        for (i = 0; i <= pa->max_order; i++) {
                xwlib_rbtree_init(&pa->odrbtree[i].tree);
                pa->odrbtree[i].leftmost = NULL;
                pa->odrbtree[i].owner = pa;
                pa->odrbtree[i].order = i;
                xwos_sqlk_init(&pa->odrbtree[i].lock);
        }
        for (i = 0; i < nr; i++) {
                pa->pgarray[i].order = XWMM_MEMPOOL_PAGE_ORDER_CMB;
                pa->pgarray[i].mapping = XWMM_MEMPOOL_PAGE_MAPPING_INVAILD;
                pa->pgarray[i].attr.free.seq = i;
                xwlib_rbtree_init_node(&pa->pgarray[i].attr.free.rbnode);
                pa->pgarray[i].data.value = 0;
        }
        // cppcheck-suppress [misra-c2012-17.7]
        xwmm_mempool_page_odrbtree_add(&pa->odrbtree[pa->max_order],
                                       &pa->pgarray[0]);
 
        pa->i_a.malloc = xwmm_mempool_page_i_a_malloc;
        pa->i_a.free = xwmm_mempool_page_i_a_free;
 
        return XWOK;
 
err_aligned:
err_mem2small:
        return rc;
}

函数调用图:

这是这个函数的调用关系图:

xwmm_mempool_page_find()

xwer_t xwmm_mempool_page_find	(	struct xwmm_mempool_page_allocator *	pa,
		void *	mem,
		struct xwmm_mempool_page **	pgbuf
	)

依据内存地址查找页

参数

[in]	pa	页分配器的指针
[in]	mem	内存地址
[out]	pgbuf	指向缓冲区的指针，通过此缓冲区返回申请到的页控制块的指针

返回

错误码

返回值

XWOK	没有错误
-ERANGE	内存地址不在内存池的范围内

<No error

在文件 page.c 第 519 行定义.

{
        xwer_t rc;
        struct xwmm_mempool_page * pg;
 
        if (((xwptr_t)mem < pa->zone.origin) ||
            ((xwptr_t)mem >= (pa->zone.origin + pa->zone.size))) {
                rc = -ERANGE;
        } else {
                pg = xwmm_mempool_mem_to_page(pa, mem);
                while (XWMM_MEMPOOL_PAGE_ORDER_CMB == pg->order) {
                        pg--;
                }
                *pgbuf = pg;
                rc = XWOK;
        }
        return rc;
}

函数调用图:

这是这个函数的调用关系图:

xwmm_mempool_page_free()

xwer_t xwmm_mempool_page_free	(	struct xwmm_mempool_page_allocator *	pa,
		struct xwmm_mempool_page *	pg
	)

XWMM API：释放一页内存

参数

[in]	pa	页分配器的指针
[in]	pg	页控制块的指针

返回

错误码

返回值

XWOK	没有错误
-EALREADY	页内存已释放

<No error

在文件 page.c 第 194 行定义.

{
        xwer_t rc;
 
        if (XWMM_MEMPOOL_PAGE_MAPPING_FREE == pg->mapping) {
                rc = -EALREADY;
                goto err_already;
        }
        pg->mapping = XWMM_MEMPOOL_PAGE_MAPPING_INVAILD;
        pg->attr.free.seq = xwmm_mempool_page_get_seq(pa, pg);
        xwlib_rbtree_init_node(&pg->attr.free.rbnode);
        pg->data.value = 0;
        xwmm_mempool_page_combine(pa, pg);
        return XWOK;
 
err_already:
        return rc;
}

函数调用图:

这是这个函数的调用关系图:

xwmm_mempool_realloc()

xwer_t xwmm_mempool_realloc	(	struct xwmm_mempool *	mp,
		xwsz_t	size,
		void **	membuf
	)

XWMM API：调整内存大小

参数

[in]	mp	内存池的指针
[in]	size	申请的大小，当size == 0，realloc等价于free
[in,out]	membuf	指向缓冲区的指针，此缓冲区 (I) 作为输入时，当*membuf == NULL，realloc等价于malloc (O) 作为输出时，通过此缓冲区返回申请到的内存的首地址

返回

错误码

返回值

XWOK	没有错误
-EFAULT	空指针
-ENOMEM	内存不足
-ERANGE	内存地址不在内存池的范围内

注解

• 同步/异步：同步
• 上下文：中断、中断底半部、线程
• 重入性：可重入

• 此API类似于C11标准中的 realloc() 函数：
  • 当 *membuf 为 NULL ，此函数等价于 xwmm_mempool_mealloc(mp, size, membuf) ；
  • 当 *membuf 不为 NULL 且 size 为 0 ， 此函数等价于 xwmm_mempool_free(mp, *membuf) ，并且通过 *membuf 返回 NULL ；
  • 当 *membuf 不为 NULL 且 size 比之前的小 ，此函数不重新申请内存，直接返回原来的 *membuf 以及 XWOK ；
  • 当 *membuf 不为 NULL 且 size 比之前的大 ，此函数会尝试重新申请内存：
    • 如果申请失败，原来的内存不会受影响，且通过 *membuf 返回 NULL 以及 错误码；
    • 如果申请成功，会将旧内存空间的内容移动到新内存空间内，然后返回新的 *membuf 以及 XWOK 。

<No error

<No error

<No error

<No error

<No error

在文件 allocator.c 第 418 行定义.

{
        xwer_t rc;
 
        XWOS_VALIDATE((mp), "nullptr", -EFAULT);
        XWOS_VALIDATE((membuf), "nullptr", -EFAULT);
 
        if (NULL == *membuf) {
                rc = xwmm_mempool_malloc(mp, size, membuf);
        } else if ((xwsz_t)0 == size) {
                rc = xwmm_mempool_free(mp, *membuf);
                if (XWOK == rc) {
                        *membuf = NULL;
                }
        } else {
                struct xwmm_mempool_page * pg;
                void * oldmem;
                void * newmem;
 
                oldmem = *membuf;
                rc = xwmm_mempool_page_find(&mp->pa, oldmem, &pg);
                if (XWOK == rc) {
                        if (size <= pg->data.value) {
                                rc = XWOK;
                        } else {
                                rc = xwmm_mempool_malloc(mp, size, &newmem);
                                if (XWOK == rc) {
                                        // cppcheck-suppress [misra-c2012-17.7]
                                        memcpy(newmem, oldmem, pg->data.value);
                                        rc = xwmm_mempool_free(mp, oldmem);
                                        if (XWOK == rc) {
                                                *membuf = newmem;
                                        } else {
                                                // cppcheck-suppress [misra-c2012-17.7]
                                                xwmm_mempool_free(mp, newmem);
                                                *membuf = NULL;
                                        }
                                } else {
                                        *membuf = NULL;
                                }
                        }
                } else {
                        *membuf = NULL;
                }
        }
        return rc;
}

函数调用图: