• 内存池的实现与场景分析

    目录

     

    1.为什么要有内存池？

    2.内存池的实现

    方案一：链表

    方法二：固定块大小

    方案三

    block用于管理小块内存

    整体框架

     实现代码

    1.为什么要有内存池？

    内存池是对堆上申请出来的空间进行管理的。

    因为频繁分配内存，并且每次只占用一点内存，会出现很多的内存碎片。内存池就是为了避免频繁分配，释放以及减少内存碎片的问题。

    2.内存池的实现

    1. 分配的大小是不确定的。
    2. 什么时候分配不确定。

    方案一：链表

    用链表节点，节点结构体有四个内容，第一个是内存块地址的指针，第二个指向下一个链表节点，第三个是每个节点还有（flag标志）分配的内存大小，第四个是否可以使用。

    使用方式:

    如果有新的分配请求，就会依次遍历，查找节点（flag来标记是否已经分配或者释放），用该节点分配的内存。如果没有，就会在末尾添加新的节点。

    存在缺点：

    如果第一次使用64字节的内存块，并释放了，下次再使用50字节的呢，需要在末尾继续添加，这样会造成很多无法利用的内存碎片的产生。

    方法二：固定块大小

    分配固定内存块大小，划分大小的等级，符合要求最小大小等级的内存块，分配给它，这样可以避免生成太多碎片。通过索引找到对应的固定内存链表，遍历链表，找到能用的结点。

    缺点：
    查找速度慢(使用链表)，小块的回收会出现间隙

    方案三

    对于内存可以 划分为大块（4k）和小块（大于4K）

    大块

            可以划定一个值，对大于该值的可以认定为大块，小于该值可以认定为小块，大块直接用链表去存储(因为内存池最关心的，以及解决的是小块的内存碎片问题，而大块是最希望看到的，不需要内存池去解决，它的碎片少,因此使用链表去管理就行)

    小块

            对于小块，可以放入一个比较大的块(block)里面，在block里面分配一块空间给小块去使用。如果当前block内小块都没在使用了，那么就将整个block一起释放。block之间也用链表进行连接起来，可以动态地管理分配和释放block（这些都是用来存储小块内存）。通过block可以方便小块内存地管理，可以减少内存碎片。

    block用于管理小块内存

    一个block的头部，有last,end，next以及其他参数组成，通过链表将blocks组织起来(next指针)

     例如block大小为4k，需要使用一块8bytes的内存空间，只要把8bytes的首地址(last指向的内存)返回即可，然后将last指向8bytes的内存空间末尾，用于下一次分配使用

    整体框架

    小块往右边的block里面放。大块往下边直接整块从链表头部插入进去。

     实现代码

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5.  
    6. #include 
    7.  
    8.  
    9. #define MP_ALIGNMENT       		32
    10. #define MP_PAGE_SIZE			4096
    11. #define MP_MAX_ALLOC_FROM_POOL	(MP_PAGE_SIZE-1)
    12.  
    13. #define mp_align(n, alignment) (((n)+(alignment-1)) & ~(alignment-1))
    14.  
    15. //用来做对齐的，比如以4个字节对齐，    那么0x35-->0x36
    16. #define mp_align_ptr(p, alignment) (void *)((((size_t)p)+(alignment-1)) & ~(alignment-1))
    17.  
    18.  
    19. //大块
    20. struct mp_large_s {
    21. 	struct mp_large_s *next;
    22. 	void *alloc;
    23. };
    24. //block的头
    25. struct mp_node_s {
    26. 	unsigned char *last;	//指向下一个空余的内存开始地址
    27. 	unsigned char *end;		//指向当前block末尾
    28. 	struct mp_node_s *next;	//指向下一个block
    29. 	size_t failed;
    30. };
    31.  
    32. struct mp_pool_s {
    33.  
    34. 	size_t max;//能分配的最大size
    35.  
    36. 	struct mp_node_s *current;	//block当前的指针(遍历查找的起点)
    37. 	struct mp_large_s *large;	//大块
    38.  
    39. 	struct mp_node_s head[0];	//第一个block(第一个block是放在mp_pool_s中的，剩下的用链表连接。大小为 头+数据,因为数据大小size不确定，因此用柔性数组)
    40.  
    41. };
    42.  
    43. struct mp_pool_s *mp_create_pool(size_t size);
    44. void mp_destory_pool(struct mp_pool_s *pool);
    45. void *mp_alloc(struct mp_pool_s *pool, size_t size);
    46. void *mp_nalloc(struct mp_pool_s *pool, size_t size);
    47. void *mp_calloc(struct mp_pool_s *pool, size_t size);
    48. void mp_free(struct mp_pool_s *pool, void *p);
    49.  
    50. //API
    51. struct mp_pool_s *mp_create_pool(size_t size) {
    52.  
    53. 	struct mp_pool_s *p;
    54. 	int ret = posix_memalign((void **)&p, MP_ALIGNMENT, size + sizeof(struct mp_pool_s) + sizeof(struct mp_node_s));
    55. 	if (ret) {
    56. 		return NULL;
    57. 	}
    58. 	
    59. 	p->max = (size < MP_MAX_ALLOC_FROM_POOL) ? size : MP_MAX_ALLOC_FROM_POOL;
    60. 	p->current = p->head;
    61. 	p->large = NULL;
    62.  
    63. 	p->head->last = (unsigned char *)p + sizeof(struct mp_pool_s) + sizeof(struct mp_node_s);
    64. 	p->head->end = p->head->last + size;
    65.  
    66. 	p->head->failed = 0;
    67.  
    68. 	return p;
    69.  
    70. }
    71. //API
    72. void mp_destory_pool(struct mp_pool_s *pool) {
    73.  
    74. 	struct mp_node_s *h, *n;
    75. 	struct mp_large_s *l;
    76.  
    77. 	for (l = pool->large; l; l = l->next) {
    78. 		if (l->alloc) {
    79. 			free(l->alloc);
    80. 		}
    81. 	}
    82.  
    83. 	h = pool->head->next;
    84.  
    85. 	while (h) {
    86. 		n = h->next;
    87. 		free(h);
    88. 		h = n;
    89. 	}
    90.  
    91. 	free(pool);
    92.  
    93. }
    94.  
    95. void mp_reset_pool(struct mp_pool_s *pool) {
    96. 	struct mp_node_s *h;
    97. 	struct mp_large_s *l;
    98.  
    99. 	for (l = pool->large; l; l = l->next) {
    100. 		if (l->alloc) {
    101. 			free(l->alloc);
    102. 		}
    103. 	}
    104.  
    105. 	pool->large = NULL;
    106.  
    107. 	for (h = pool->head; h; h = h->next) {
    108. 		h->last = (unsigned char *)h + sizeof(struct mp_node_s);
    109. 	}
    110.  
    111. }
    112.  
    113. static void *mp_alloc_block(struct mp_pool_s *pool, size_t size) {
    114.  
    115. 	unsigned char *m;
    116. 	struct mp_node_s *h = pool->head;
    117. 	size_t psize = (size_t)(h->end - (unsigned char *)h);//小块的  头+数据部分  的大小
    118. 	
    119. 	int ret = posix_memalign((void **)&m, MP_ALIGNMENT, psize);//分配一个 小块
    120. 	if (ret) return NULL;
    121.  
    122. 	struct mp_node_s *p, *new_node, *current;
    123. 	new_node = (struct mp_node_s*)m;
    124.  
    125. 	new_node->end = m + psize;
    126. 	new_node->next = NULL;
    127. 	new_node->failed = 0;
    128.  
    129. 	m += sizeof(struct mp_node_s);//添加头部
    130. 	m = mp_align_ptr(m, MP_ALIGNMENT);//头部对齐
    131. 	new_node->last = m + size;
    132.  
    133. 	current = pool->current;
    134.  
    135. 	for (p = current; p->next; p = p->next) {
    136. 		if (p->failed++ > 4) {//如果failed > 4, 就漏过这个node(也就是说每个块，在查找块的时候只允许失败4次，失败4次后，让current指向该节点的下一个)
    137. 			current = p->next;
    138. 		}
    139. 	}
    140. 	p->next = new_node;
    141.  
    142. 	pool->current = current ? current : new_node;
    143.  
    144. 	return m;
    145.  
    146. }
    147.  
    148. static void *mp_alloc_large(struct mp_pool_s *pool, size_t size) {
    149.  
    150. 	void *p = malloc(size);
    151. 	if (p == NULL) return NULL;
    152.  
    153. 	size_t n = 0;
    154. 	struct mp_large_s *large;
    155. 	for (large = pool->large; large; large = large->next) {
    156. 		if (large->alloc == NULL) {
    157. 			large->alloc = p;
    158. 			return p;
    159. 		}
    160. 		if (n ++ > 3) break;
    161. 	}
    162.  
    163. 	large = mp_alloc(pool, sizeof(struct mp_large_s));
    164. 	if (large == NULL) {
    165. 		free(p);
    166. 		return NULL;
    167. 	}
    168.  
    169. 	large->alloc = p;
    170. 	large->next = pool->large;//链表节点头部插入节点
    171. 	pool->large = large;
    172.  
    173. 	return p;
    174. }
    175.  
    176. void *mp_memalign(struct mp_pool_s *pool, size_t size, size_t alignment) {
    177.  
    178. 	void *p;
    179. 	
    180. 	int ret = posix_memalign(&p, alignment, size);
    181. 	if (ret) {
    182. 		return NULL;
    183. 	}
    184.  
    185. 	struct mp_large_s *large = mp_alloc(pool, sizeof(struct mp_large_s));
    186. 	if (large == NULL) {
    187. 		free(p);
    188. 		return NULL;
    189. 	}
    190.  
    191. 	large->alloc = p;
    192. 	large->next = pool->large;
    193. 	pool->large = large;
    194.  
    195. 	return p;
    196. }
    197.  
    198.  
    199.  
    200. //API
    201. void *mp_alloc(struct mp_pool_s *pool, size_t size) {
    202.  
    203. 	unsigned char *m;
    204. 	struct mp_node_s *p;
    205.  
    206. 	if (size <= pool->max) {
    207.  
    208. 		p = pool->current;
    209.  
    210. 		do {
    211. 			
    212. 			m = mp_align_ptr(p->last, MP_ALIGNMENT);//内存对齐
    213. 			if ((size_t)(p->end - m) >= size) {//block中要有足够空间能放下当前的size
    214. 				p->last = m + size;
    215. 				return m;
    216. 			}
    217. 			p = p->next;//查找有空间可以装下的block
    218. 		} while (p);
    219.  
    220. 		return mp_alloc_block(pool, size);//没有block可以装了，那就创建一个小块,并分配
    221. 	}
    222.  
    223. 	return mp_alloc_large(pool, size);//分配一个大块
    224. 	
    225. }
    226.  
    227.  
    228. void *mp_nalloc(struct mp_pool_s *pool, size_t size) {
    229.  
    230. 	unsigned char *m;
    231. 	struct mp_node_s *p;
    232.  
    233. 	if (size <= pool->max) {
    234. 		p = pool->current;
    235.  
    236. 		do {
    237. 			m = p->last;
    238. 			if ((size_t)(p->end - m) >= size) {
    239. 				p->last = m+size;
    240. 				return m;
    241. 			}
    242. 			p = p->next;
    243. 		} while (p);
    244.  
    245. 		return mp_alloc_block(pool, size);
    246. 	}
    247.  
    248. 	return mp_alloc_large(pool, size);
    249. 	
    250. }
    251.  
    252. void *mp_calloc(struct mp_pool_s *pool, size_t size) {
    253.  
    254. 	void *p = mp_alloc(pool, size);
    255. 	if (p) {
    256. 		memset(p, 0, size);
    257. 	}
    258.  
    259. 	return p;
    260. 	
    261. }
    262. //API    只释放大块
    263. void mp_free(struct mp_pool_s *pool, void *p) {
    264.  
    265. 	struct mp_large_s *l;
    266. 	for (l = pool->large; l; l = l->next) {
    267. 		if (p == l->alloc) {
    268. 			free(l->alloc);
    269. 			l->alloc = NULL;
    270.  
    271. 			return ;
    272. 		}
    273. 	}
    274. 	
    275. }
    276.  
    277.  
    278. int main(int argc, char *argv[]) {
    279.  
    280. 	int size = 1 << 12;
    281.  
    282. 	struct mp_pool_s *p = mp_create_pool(size);
    283.  
    284. 	int i = 0;
    285. 	for (i = 0;i < 10;i ++) {
    286.  
    287. 		void *mp = mp_alloc(p, 512);
    288. //		mp_free(mp);
    289. 	}
    290.  
    291. 	//printf("mp_create_pool: %ld\n", p->max);
    292. 	printf("mp_align(123, 32): %d, mp_align(17, 32): %d\n", mp_align(24, 32), mp_align(17, 32));
    293. 	//printf("mp_align_ptr(p->current, 32): %lx, p->current: %lx, mp_align(p->large, 32): %lx, p->large: %lx\n", mp_align_ptr(p->current, 32), p->current, mp_align_ptr(p->large, 32), p->large);
    294.  
    295. 	int j = 0;
    296. 	for (i = 0;i < 5;i ++) {
    297.  
    298. 		char *pp = mp_calloc(p, 32);
    299. 		for (j = 0;j < 32;j ++) {
    300. 			if (pp[j]) {
    301. 				printf("calloc wrong\n");
    302. 			}
    303. 			printf("calloc success\n");
    304. 		}
    305. 	}
    306.  
    307. 	//printf("mp_reset_pool\n");
    308.  
    309. 	for (i = 0;i < 5;i ++) {
    310. 		void *l = mp_alloc(p, 8192);
    311. 		mp_free(p, l);
    312. 	}
    313.  
    314. 	mp_reset_pool(p);
    315.  
    316. 	//printf("mp_destory_pool\n");
    317. 	for (i = 0;i < 58;i ++) {
    318. 		mp_alloc(p, 256);
    319. 	}
    320.  
    321. 	mp_destory_pool(p);
    322.  
    323. 	return 0;
    324.  
    325. }

     

     推荐一个不错的学习网站 C/C++后台高级服务器https://ke.qq.com/course/417774?flowToken=1010783

  • 相关阅读:
    卷积神经网络的结构组成与解释（详细介绍）
    10个好用的Mac数据恢复软件推荐—恢复率高达99%
    C2基础设施威胁情报对抗策略
    Python中如何使用__slots__限制对象属性来节约内存
    前端实现SuperMap iServer服务增（发布）删改查和刷新的方法.md
    《护理教育学》名词解释、简答题、问答题汇总
    当transcational遇上synchronized
    【LeetCode】5. 最长回文子串
    中国钨粉行业市场研究与投资预测报告（2022版）
    Mysql 单行处理函数打字练习—— 让你熟悉必要的函数，提高查询效率
  • 原文地址：https://blog.csdn.net/kakaka666/article/details/126961712