C语言实现简易内存池

于 2025-06-24 20:31:05 发布
阅读量202 收藏 2
点赞数 1
CC 4.0 BY-SA版权
文章标签： c语言 linux 前端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/csdddd55/article/details/148878831

https://cloud.tencent.com/developer/article/2325061

上述链接较为系统讲述了内存池，以及完整实现简易内存池的代码和思路。需要学习内存池的可以直接跳转进行学习。本帖子是基于此贴进行打补丁，或者说介绍本人在学习过程中遇到的问题，以及如何解决。

一、vs平台引用posix_memalign失败

如果在visual studio2022中引用posix_memalign失败，可以自己构造一下这个函数代码如下

//功能函数
int my_posix_memalign(void** memptr, size_t alignment, size_t size) {
    // 检查 alignment 是否是 2 的幂，并且 ≥ sizeof(void*)
    if ((alignment & (alignment - 1)) != 0 || alignment < sizeof(void*)) {
        return EINVAL; // 无效对齐
    }

    // 分配额外空间用于存储原始指针（用于 free）
    void* raw_ptr = malloc(size + alignment - 1 + sizeof(void*));
    if (!raw_ptr) {
        return ENOMEM; // 内存不足
    }

    // 计算对齐后的地址
    uintptr_t aligned_ptr = ((uintptr_t)raw_ptr + sizeof(void*) + alignment - 1) & ~(alignment - 1);

    // 存储原始指针（用于 free）
    *((void**)aligned_ptr - 1) = raw_ptr;

    // 返回对齐后的指针
    *memptr = (void*)aligned_ptr;

    return 0; // 成功
}

当然构造这个函数的时候需要引用头文件

#include <stdlib.h>
#include <stdint.h> // 用于 uintptr_t
#include <errno.h>

二、其monitor函数运行问题

可以替换为较为简单的monitor函数，我的如下

//监控内存池
void monitor_mp_pool(mp_pool_s* pool) {
    printf("\r\n\r\n=================start monitor===================\r\n\r\n");
    mp_node_s* current = NULL;
    int index = 0;
    for (current = pool->head; current; current = current->next) {
        index++;
        if (pool->cur == current) {
            printf("current ===>> 第%d块\n", index);
        }
        if (index == 1) {
            printf("第%02d块小内存块==已使用：%4ld字节==剩余：%4ld字节==失败次数：%4d次==引用次数：%4d次\n", index, (unsigned char*)current->last - (unsigned char*)pool,
                current->end - current->last, current->failed, current->quote);
        }
        else {
            printf("第%02d块小内存块==已使用：%4ld字节==剩余：%4ld字节==失败次数：%4d次==引用次数：%4d次\n", index, (unsigned char*)current->last - (unsigned char*)current,
                current->end - current->last, current->failed, current->quote);
        }
    }
    mp_large_s* large = NULL;
    int i = 0;
    for (large = pool->large_head; large; large = large->next) {
        i++;
        if (large->addr_large) {
            printf("第%d块大内存块，大小为%ld字节\n", i, large->size);
        }
    }
    printf("\r\n\r\n===============end monitor==========\r\n\r\n");
}

三、还有一些小问题，可以拷贝我的完整代码

head头文件

#pragma once
/*nginx的原理简单实现*/
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <math.h>
#include <stdlib.h>
#include <stdint.h> // 用于 uintptr_t
#include <errno.h> 
//页面大小以《4k》为标准
//对齐大小为16bit
#define PAGE_SIZE 4096
#define MP_ALIGNMENT 16
//宏定义的对齐函数
#define mp_align(n, alignment) (((n)+(alignment-1)) & ~(alignment-1))
#define mp_align_ptr(p, alignment) (void *)((((size_t)p)+(alignment-1)) & ~(alignment-1))
//定义数据结构
//小块管理数据结构
typedef struct mp_node_s {
	struct mp_node_s* next;//小块链表的下一个
	unsigned char* last;//开始
	unsigned char* end;//结束
	int quote;//引用计数
	int failed;//失败次数
}mp_node_s;
//大块管理数据结构
typedef struct mp_large_s {
	struct mp_large_s* next;//大块链表下一个
	void* addr_large;
	int size;
}mp_large_s;
typedef struct mp_pool_s {
	mp_node_s* cur;
	mp_node_s* head;
	mp_large_s* large_head;
}mp_pool_s;

//功能函数
int my_posix_memalign(void** memptr, size_t alignment, size_t size) {
    // 检查 alignment 是否是 2 的幂，并且 ≥ sizeof(void*)
    if ((alignment & (alignment - 1)) != 0 || alignment < sizeof(void*)) {
        return EINVAL; // 无效对齐
    }

    // 分配额外空间用于存储原始指针（用于 free）
    void* raw_ptr = malloc(size + alignment - 1 + sizeof(void*));
    if (!raw_ptr) {
        return ENOMEM; // 内存不足
    }

    // 计算对齐后的地址
    uintptr_t aligned_ptr = ((uintptr_t)raw_ptr + sizeof(void*) + alignment - 1) & ~(alignment - 1);

    // 存储原始指针（用于 free）
    *((void**)aligned_ptr - 1) = raw_ptr;

    // 返回对齐后的指针
    *memptr = (void*)aligned_ptr;

    return 0; // 成功
}

mp_pool_s* mp_create_pool(size_t size) {
    if (size <= 0)return NULL;
    mp_pool_s* pool;
    if (size < PAGE_SIZE || size % PAGE_SIZE != 0) {
        size = PAGE_SIZE;
    }
    int ret = my_posix_memalign((void**)&pool, MP_ALIGNMENT, size);
    if (ret != 0)return NULL;
    pool->cur = pool->head = (mp_node_s*)((unsigned char*)pool + sizeof(mp_pool_s));
    pool->large_head = NULL;
    pool->head->last = ((unsigned char*)pool + sizeof(mp_pool_s) + sizeof(mp_node_s));
    pool->head->end = (unsigned char*)pool + PAGE_SIZE;
    pool->head->quote = pool->head->failed = 0;
    pool->head->next = NULL;
    return pool;
}

void mp_destroy_pool(mp_pool_s* pool) {
    mp_large_s* large;
    for (large = pool->large_head; large; large = large->next) {
        if (large->addr_large) {
            free(large->addr_large);
        }
    }
    mp_node_s* node;
    node = pool->head->next;
    while (node) {
        mp_node_s* tmp = node->next;
        free(node);
        node = tmp;
    }
    free(pool);
}

void* mp_malloc_s(size_t size, mp_pool_s* pool);
void* mp_malloc_large(size_t size, mp_pool_s* pool) {
    unsigned char* big_addr = NULL;
    int ret = my_posix_memalign((void**)&big_addr, MP_ALIGNMENT, size);
    if (ret != 0)return NULL;
    mp_large_s* large = NULL;
    large = pool->large_head;
    int n = 0;//统计失败次数
    for (; large; large = large->next) {
        if (large->addr_large == NULL) {
            large->size = size;
            large->addr_large = big_addr;
            return big_addr;
        }
        if (n++ > 4)break;
    }
    large = (mp_large_s*)mp_malloc_s(sizeof(mp_large_s), pool);
    if (large == NULL) {
        free(big_addr);
        return NULL;
    }
    large->addr_large = big_addr;
    large->next = pool->large_head;
    pool->large_head = large;
    large->size = size;
    return big_addr;
}
void* mp_malloc_block(size_t size, mp_pool_s* pool) {
    unsigned char* block = NULL;
    int ret = my_posix_memalign((void**)&block, MP_ALIGNMENT, PAGE_SIZE);
    if (ret != 0) {
        return NULL;
    }
    mp_node_s* new_node = (mp_node_s*)block;
    new_node->end = block + PAGE_SIZE;
    new_node->failed = 0;
    new_node->quote = 0;
    new_node->next = NULL;
    unsigned char* ret_addr = (unsigned char*)mp_align_ptr(block + sizeof(mp_node_s), MP_ALIGNMENT);
    new_node->last = ret_addr + size;
    new_node->quote++;

    //扩容的话说明之前的块内存不够了，失败了
    mp_node_s* pre = pool->cur;
    mp_node_s* rear = NULL;
    for (rear = pool->cur; rear->next; rear = rear->next) {
        if (rear->failed++ > 4) {
            pre = rear->next;
        }
    }
    rear->next = new_node;
    pool->cur = pre;
    return ret_addr;
}
//大于block大小进行mp_malloc_large 否则用小块malloc
void* mp_malloc_s(size_t size, mp_pool_s* pool) {
    if (size > PAGE_SIZE || size > PAGE_SIZE - sizeof(mp_node_s)) {
        return mp_malloc_large(size, pool);//建立大内存块
    }
    if (size <= 0)return NULL;
    mp_node_s* ptr_node = pool->cur;
    unsigned char* mem_addr = NULL;
    while (ptr_node) {
        mem_addr = (unsigned char*)mp_align_ptr(ptr_node->last, MP_ALIGNMENT);
        if (size <= ptr_node->end - mem_addr) {
            ptr_node->quote++;
            ptr_node->last = mem_addr + size;
            return mem_addr;//完成
        }
        else {
            ptr_node = ptr_node->next;
        }

    }
    return mp_malloc_block(size, pool);//扩容

}

void mp_free(mp_pool_s* pool, void* p) {
    mp_large_s* large = NULL;
    for (large = pool->large_head; large; large = large->next) {
        if (p == large) {
            free(large->addr_large);
            large->size = 0;
            large->addr_large = NULL;
            return;
        }
    }
    //mp_node_s释放node
    mp_node_s* node = pool->head;
    for (; node; node->next) {
        if ((unsigned char*)p >= (unsigned char*)node && (unsigned char*)p <= (unsigned char*)node->end) {
            node->quote--;
            if (node->quote == 0) {
                if (node == pool->head) {
                    node->last = (unsigned char*)pool + sizeof(mp_pool_s) + sizeof(mp_node_s);
                }
                else {
                    node->last = (unsigned char*)node + sizeof(mp_node_s);
                }
                node->failed = 0;
                pool->cur = pool->head;
            }
            return;
        }
    }
}


//监控内存池
void monitor_mp_pool(mp_pool_s* pool) {
    printf("\r\n\r\n=================start monitor===================\r\n\r\n");
    mp_node_s* current = NULL;
    int index = 0;
    for (current = pool->head; current; current = current->next) {
        index++;
        if (pool->cur == current) {
            printf("current ===>> 第%d块\n", index);
        }
        if (index == 1) {
            printf("第%02d块小内存块==已使用：%4ld字节==剩余：%4ld字节==失败次数：%4d次==引用次数：%4d次\n", index, (unsigned char*)current->last - (unsigned char*)pool,
                current->end - current->last, current->failed, current->quote);
        }
        else {
            printf("第%02d块小内存块==已使用：%4ld字节==剩余：%4ld字节==失败次数：%4d次==引用次数：%4d次\n", index, (unsigned char*)current->last - (unsigned char*)current,
                current->end - current->last, current->failed, current->quote);
        }
    }
    mp_large_s* large = NULL;
    int i = 0;
    for (large = pool->large_head; large; large = large->next) {
        i++;
        if (large->addr_large) {
            printf("第%d块大内存块，大小为%ld字节\n", i, large->size);
        }
    }
    printf("\r\n\r\n===============end monitor==========\r\n\r\n");
}

main函数代码

#include "head.h"

int main() {
    mp_pool_s* pool = mp_create_pool(PAGE_SIZE);
    monitor_mp_pool(pool);
    void* mp[30];
    int i;
    for (i = 0; i < 10; i++) {
        mp[i] = mp_malloc_s(512,pool);
        monitor_mp_pool(pool);
    }
    monitor_mp_pool(pool);

    for (i = 0; i < 10; i++) {
        mp_free(pool, mp[i]);
    }
    monitor_mp_pool(pool);
    mp_destroy_pool(pool);
    return 0;

}

厚切薯片
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值