memory pool 的高效实现（代码）

最新推荐文章于 2022-09-16 15:48:39 发布
最新推荐文章于 2022-09-16 15:48:39 发布
阅读量240 收藏 1
点赞数
分类专栏： C++ 文章标签： Google 多线程 C C# C++

mpool.h

#ifndef __febird_c_mpool_h__ #define __febird_c_mpool_h__ #include "config.h" #ifdef __cplusplus extern "C" { #endif //------------------------------------------------------------------------------------------ struct sallocator { void* (*salloc)(struct sallocator* self, size_t size); void* (*srealloc)(struct sallocator* self, void* block, size_t old_size, size_t new_size); void (*sfree)(struct sallocator* self, void* block, size_t size); }; typedef void* (*salloc_ft)(struct sallocator* self, size_t size); typedef void* (*srealloc_ft)(struct sallocator* self, void* block, size_t old_size, size_t new_size); typedef void (*sfree_ft)(struct sallocator* self, void* block, size_t size); struct fixed_mpool { struct sallocator* sa; struct mpool_chunk* pChunks; struct mpool_cell* head; size_t iNextChunk; size_t nChunks; size_t cell_size; size_t chunk_size; size_t used_cells; }; struct sfixed_mpool { //------------------------------------------------------------------------------------------ /// export a sallocator interface void* (*salloc)(struct sallocator* self, size_t size); void* (*srealloc)(struct sallocator* self, void* block, size_t old_size, size_t new_size); void (*sfree)(struct sallocator* self, void* block, size_t size); //------------------------------------------------------------------------------------------ struct fixed_mpool fmp; }; // 是否允许 mpool 分配超出 max_cell_size 的内存块 //#define FEBIRD_MPOOL_ALLOW_BIG_BLOCK #ifdef FEBIRD_MPOOL_ALLOW_BIG_BLOCK struct big_block_header { struct big_block_header *next, *prev; }; #endif struct mpool { //------------------------------------------------------------------------------------------ /// export a sallocator interface void* (*salloc)(struct sallocator* self, size_t size); void* (*srealloc)(struct sallocator* self, void* block, size_t old_size, size_t new_size); void (*sfree)(struct sallocator* self, void* block, size_t size); //------------------------------------------------------------------------------------------ /// sallocator for this mpool self struct sallocator* sa; struct fixed_mpool* fixed; size_t max_cell_size; size_t chunk_size; #ifdef FEBIRD_MPOOL_ALLOW_BIG_BLOCK size_t big_blocks; // size > max_cell_size, use malloc, this is rare case struct big_block_header big_list; #endif }; /***********************************************************************/ FEBIRD_DLL_EXPORT void fixed_mpool_init(struct fixed_mpool* mpf); FEBIRD_DLL_EXPORT void fixed_mpool_destroy(struct fixed_mpool* mpf); FEBIRD_DLL_EXPORT void* fixed_mpool_alloc(struct fixed_mpool* mpf); FEBIRD_DLL_EXPORT void fixed_mpool_free(struct fixed_mpool* mpf, void* ptr); /***********************************************************************/ /***********************************************************************/ /** * sfixed_mpool_{salloc|sfree} should only called by sallocator interface * sfixed_mpool_srealloc is an assert only hook. */ FEBIRD_DLL_EXPORT void sfixed_mpool_init(struct sfixed_mpool* mp); FEBIRD_DLL_EXPORT void sfixed_mpool_destroy(struct sfixed_mpool* mp); /***********************************************************************/ /***********************************************************************/ /** * mpool_{salloc|sfree} may called by function name, or by interface */ FEBIRD_DLL_EXPORT void mpool_init(struct mpool* mp); FEBIRD_DLL_EXPORT void mpool_destroy(struct mpool* mp); FEBIRD_DLL_EXPORT void* mpool_salloc(struct mpool* mp, size_t size); FEBIRD_DLL_EXPORT void mpool_sfree(struct mpool* mp, void* ptr, size_t size); FEBIRD_DLL_EXPORT size_t mpool_used_cells(const struct mpool* mp); FEBIRD_DLL_EXPORT size_t mpool_used_bytes(const struct mpool* mp); /***********************************************************************/ /***********************************************************************/ FEBIRD_DLL_EXPORT struct mpool* mpool_get_global(void); FEBIRD_DLL_EXPORT void* gsalloc(size_t size); FEBIRD_DLL_EXPORT void gsfree(void* ptr, size_t size); /***********************************************************************/ #ifdef __cplusplus } #endif #endif // __febird_c_mpool_h__

mpool.c

#include <stdio.h> #include <stdlib.h> #include <string.h> #include <assert.h> #include "mpool.h" /* must be power of 2 and greater than sizeof(void*) */ #define MPOOL_MIN_CELL 8 #define MPOOL_MIN_CHUNK 256 struct mpool_cell { struct mpool_cell* next; }; struct mpool_chunk { struct mpool_cell* cell; // cell array size_t size; // size in bytes; }; /**********************************************************************************/ /** * sallocator use malloc/free */ static void* malloc_salloc(struct sallocator* sa, size_t size) { return malloc(size); } static void malloc_sfree(struct sallocator* sa, void* block, size_t size) { free(block); } static void* malloc_srealloc(struct sallocator* sa, void* block, size_t old_size, size_t new_size) { return realloc(block, new_size); } /**********************************************************************************/ void* default_srealloc(struct sallocator* sa, void* ptr, size_t old_size, size_t new_size) { void* q = sa->salloc(sa, new_size); assert(old_size > 0); assert(new_size > 0); if (NULL == q) return NULL; memcpy(q, ptr, old_size < new_size ? old_size : new_size); sa->sfree(sa, ptr, old_size); return q; } static void chunk_init(struct mpool_cell* cell, size_t cell_count, size_t cell_size) { size_t i; struct mpool_cell* p = cell; assert(cell_size % MPOOL_MIN_CELL == 0); for (i = 0; i < cell_count-1; ++i) p = p->next = (struct mpool_cell*)((char*)p + cell_size); p->next = NULL; } /**********************************************************************************/ static struct sallocator fal = { &malloc_salloc, &malloc_srealloc, &malloc_sfree }; /**********************************************************************************/ void* sfixed_mpool_salloc(struct sfixed_mpool* fmp, size_t size); void* sfixed_mpool_srealloc(struct sfixed_mpool* fmp, size_t old_size, size_t new_size); void sfixed_mpool_sfree(struct sfixed_mpool* fmp, void* ptr, size_t size); /** * require initialized fields: * cell_size * size * sa [0 OR initialized] */ void fixed_mpool_init(struct fixed_mpool* fmp) { struct sallocator* al; if (NULL == fmp->sa) al = fmp->sa = &fal; else { al = fmp->sa; assert(NULL != al->salloc); assert(NULL != al->sfree); if (NULL == al->srealloc) al->srealloc = &default_srealloc; } assert(fmp->chunk_size > 0); assert(fmp->cell_size > 0); assert(fmp->cell_size < fmp->chunk_size); fmp->cell_size = (fmp->cell_size + MPOOL_MIN_CELL - 1) / MPOOL_MIN_CELL * MPOOL_MIN_CELL; fmp->chunk_size = (fmp->chunk_size + MPOOL_MIN_CHUNK - 1) / MPOOL_MIN_CHUNK * MPOOL_MIN_CHUNK; if (fmp->nChunks < MPOOL_MIN_CHUNK/sizeof(struct mpool_chunk)) fmp->nChunks = MPOOL_MIN_CHUNK/sizeof(struct mpool_chunk); fmp->iNextChunk = 0; fmp->pChunks = (struct mpool_chunk*) al->salloc(al, sizeof(struct mpool_chunk) * fmp->nChunks); if (NULL == fmp->pChunks) { fprintf(stderr , "fatal: febird.fixed_mpool_init failed, chunk[size=%zd, count=%zd]\n" , fmp->chunk_size, fmp->nChunks); abort(); } fmp->head = NULL; fmp->used_cells = 0; } void sfixed_mpool_init(struct sfixed_mpool* sfmp) { fixed_mpool_init(&sfmp->fmp); sfmp->salloc = (salloc_ft )&sfixed_mpool_salloc; sfmp->sfree = (sfree_ft )&sfixed_mpool_sfree; sfmp->srealloc = (srealloc_ft)&sfixed_mpool_srealloc; } void fixed_mpool_destroy(struct fixed_mpool* fmp) { struct sallocator* sa = fmp->sa; long i; for (i = fmp->iNextChunk - 1; i >= 0; --i) sa->sfree(sa, fmp->pChunks[i].cell, fmp->pChunks[i].size); sa->sfree(sa, fmp->pChunks, sizeof(struct mpool_chunk) * fmp->nChunks); } void sfixed_mpool_destroy(struct sfixed_mpool* sfmp) { fixed_mpool_destroy(&sfmp->fmp); } struct mpool_cell* fixed_mpool_add_chunk(struct fixed_mpool* fmp) { struct mpool_cell* cell; assert(fmp->pChunks != NULL); if (fmp->iNextChunk == fmp->nChunks) { size_t old_size = sizeof(struct mpool_chunk) * fmp->nChunks; size_t new_size = 2 * old_size; // allocate new chunk array struct mpool_chunk* c = (struct mpool_chunk*) fmp->sa->srealloc(fmp->sa, fmp->pChunks, old_size, new_size); if (NULL == c) return NULL; fmp->pChunks = c; fmp->nChunks *= 2; // chunk array expanded 2 fmp->chunk_size *= 2; // chunk_size expanded 2 also } // allocate a new cell array cell = (struct mpool_cell*)fmp->sa->salloc(fmp->sa, fmp->chunk_size); if (NULL == cell) return NULL; fmp->pChunks[fmp->iNextChunk].cell = cell; fmp->pChunks[fmp->iNextChunk].size = fmp->chunk_size; fmp->iNextChunk++; chunk_init(cell, fmp->chunk_size / fmp->cell_size, fmp->cell_size); /* alloc cell */ fmp->used_cells++; fmp->head = cell->next; return cell; } #define FIXED_MPOOL_IMPL_ALLOC(fmp) \ { \ struct mpool_cell* cell = fmp->head;\ if (cell) { \ fmp->used_cells++; \ fmp->head = cell->next; \ return cell; \ } \ return fixed_mpool_add_chunk(fmp); \ } /***************************************************************/ #define FIXED_MPOOL_IMPL_FREE(fmp, ptr) \ { \ struct mpool_cell* cell = (struct mpool_cell*)ptr; \ cell->next = fmp->head; \ fmp->used_cells--; \ fmp->head = cell; \ } /***************************************************************/ void* fixed_mpool_alloc(struct fixed_mpool* fmp) FIXED_MPOOL_IMPL_ALLOC(fmp) void* sfixed_mpool_salloc(struct sfixed_mpool* sfmp, size_t size) { if (size != sfmp->fmp.cell_size) { fprintf(stderr, "fatal: sfixed_mpool_salloc:[cell_size=%zd, request_size=%zd]\n", sfmp->fmp.cell_size, size); abort(); } FIXED_MPOOL_IMPL_ALLOC((&sfmp->fmp)) } void fixed_mpool_free(struct fixed_mpool* fmp, void* ptr) FIXED_MPOOL_IMPL_FREE(fmp, ptr) void sfixed_mpool_sfree(struct sfixed_mpool* sfmp, void* ptr, size_t size) { if (size != sfmp->fmp.cell_size) { fprintf(stderr, "fatal: sfixed_mpool_salloc:[cell_size=%zd, request_size=%zd]\n", sfmp->fmp.cell_size, size); abort(); } FIXED_MPOOL_IMPL_FREE((&sfmp->fmp), ptr) } static void* sfixed_mpool_srealloc(struct sfixed_mpool* fmp, size_t old_size, size_t new_size) { fprintf(stderr, "fatal: sfixed_mpool_srealloc: this function shuold not be called\n"); abort(); return NULL; // avoid warning } /**********************************************************************************/ /** * require initialized fields: * max_cell_size * size * sa [0 OR initialized] */ void mpool_init(struct mpool* mp) { int i, nFixed; struct sallocator* al; assert(mp->max_cell_size < mp->chunk_size); if (NULL == mp->salloc) al = mp->sa = &fal; else { al = mp->sa; assert(NULL != al->salloc); assert(NULL != al->sfree); if (NULL == al->srealloc) al->srealloc = &default_srealloc; } mp->salloc = (salloc_ft)&mpool_salloc; mp->sfree = (sfree_ft)&mpool_sfree; mp->srealloc = (srealloc_ft)&default_srealloc; mp->max_cell_size = (mp->max_cell_size + MPOOL_MIN_CELL - 1) / MPOOL_MIN_CELL * MPOOL_MIN_CELL; mp->chunk_size = (mp->chunk_size + MPOOL_MIN_CHUNK - 1) / MPOOL_MIN_CHUNK * MPOOL_MIN_CHUNK; nFixed = mp->max_cell_size / MPOOL_MIN_CELL; mp->fixed = (struct fixed_mpool*)al->salloc(al, sizeof(struct fixed_mpool) * nFixed); if (NULL == mp->fixed) { fprintf(stderr, "fatal: febird.mpool_init[max_cell_size=%zd, size=%zd]\n" , mp->max_cell_size, mp->chunk_size); abort(); } for (i = 0; i < nFixed; ++i) { mp->fixed[i].cell_size = (i + 1) * MPOOL_MIN_CELL; mp->fixed[i].chunk_size = mp->chunk_size; mp->fixed[i].nChunks = 16; mp->fixed[i].sa = mp->sa; fixed_mpool_init(&mp->fixed[i]); } #ifdef FEBIRD_MPOOL_ALLOW_BIG_BLOCK mp->big_blocks = 0; mp->big_list.prev = mp->big_list.next = &mp->big_list; #endif } void mpool_destroy(struct mpool* mp) { size_t i, nFixed; #ifdef FEBIRD_MPOOL_ALLOW_BIG_BLOCK struct big_block_header *p; for (i = 0, p = mp->big_list.next; p != &mp->big_list; ++i) { struct big_block_header *q; if (i > mp->big_blocks) { fprintf(stderr, "fatal: febird.mpool_destroy\n"); abort(); } q = p->next; free(p); p = q; } assert(i == mp->big_blocks); #endif nFixed = mp->max_cell_size / MPOOL_MIN_CELL; for (i = 0; i < nFixed; ++i) { fixed_mpool_destroy(&mp->fixed[i]); } mp->sa->sfree(mp->sa, mp->fixed, sizeof(struct fixed_mpool) * nFixed); } void* mpool_salloc(struct mpool* mp, size_t size) { size_t idx; struct fixed_mpool* fmp; #ifdef FEBIRD_MPOOL_ALLOW_BIG_BLOCK if (size > mp->max_cell_size) { // this is rare case struct big_block_header *p, *h; p = (struct big_block_header*)malloc(sizeof(struct big_block_header) + size); if (p) { h = &mp->big_list; p->prev = h; p->next = h->next; h->next->prev = p; h->next = p; mp->big_blocks++; return (p + 1); } else return NULL; } #else if (size > mp->max_cell_size) { fprintf(stderr, "fatal: mpool_salloc: [size=%zd, max_cell_size=%zd]\n", size, mp->max_cell_size); abort(); } #endif assert(size > 0); idx = (size - 1) / MPOOL_MIN_CELL; fmp = &mp->fixed[idx]; FIXED_MPOOL_IMPL_ALLOC(fmp) } void mpool_sfree(struct mpool* mp, void* ptr, size_t size) { size_t idx; struct fixed_mpool* fmp; #ifdef FEBIRD_MPOOL_ALLOW_BIG_BLOCK if (size > mp->max_cell_size) { // this is rare case struct big_block_header* bbh = (struct big_block_header*)ptr - 1; bbh->prev->next = bbh->next; bbh->next->prev = bbh->prev; free(bbh); mp->big_blocks--; return; } #else assert(size <= mp->max_cell_size); #endif assert(size > 0); idx = (size - 1) / MPOOL_MIN_CELL; fmp = &mp->fixed[idx]; FIXED_MPOOL_IMPL_FREE(fmp, ptr) } size_t mpool_used_cells(const struct mpool* mp) { size_t i, n = mp->max_cell_size / MPOOL_MIN_CELL; size_t used = 0; for (i = 0; i < n; ++i) used += mp->fixed[i].used_cells; return used; } size_t mpool_used_bytes(const struct mpool* mp) { size_t i, n = mp->max_cell_size / MPOOL_MIN_CELL; size_t used = 0; for (i = 0; i < n; ++i) used += mp->fixed[i].cell_size * mp->fixed[i].used_cells; return used; } static struct mpool global_mpool = {0}; static void destroy_global_mpool(void) { if (global_mpool.sa) mpool_destroy(&global_mpool); } struct mpool* mpool_get_global(void) { if (NULL == global_mpool.sa) { global_mpool.chunk_size = 4096; global_mpool.max_cell_size = 256; global_mpool.sa = &fal; mpool_init(&global_mpool); atexit(&destroy_global_mpool); } return &global_mpool; } void* gsalloc(size_t size) { return mpool_salloc(&global_mpool, size); } void gsfree(void* ptr, size_t size) { mpool_sfree(&global_mpool, ptr, size); }

 

 

BenchMark

#include <vector>

#include <febird/c/mpool.h>
#include <febird/profiling.h>

void bench(int n)
{
	using namespace std;

	std::allocator<sample_data> stdal;
	struct fixed_mpool fmp = {0};
	fmp.cell_size = sizeof(sample_data);
	fmp.chunk_size = 8192;
	fmp.nChunks = 1024;
	fixed_mpool_init(&fmp);

	febird::profiling prof;

	vector<sample_data*> vp0(n), vp1(n);

	long long t0, t1, t2, t3, t4, t5, t6;
	t0 = prof.current();
	for (int i = 0; i+3 < n; i+=4)
	{
		vp0[i+0] = stdal.allocate(1);
		vp0[i+1] = stdal.allocate(1);
		vp0[i+2] = stdal.allocate(1);
		vp0[i+3] = stdal.allocate(1);
	}
	t1 = prof.current();
	for (int i = 0; i+3 < n; i+=4)
	{
		vp1[i+0] = (sample_data*)fixed_mpool_alloc(&fmp);
		vp1[i+1] = (sample_data*)fixed_mpool_alloc(&fmp);
		vp1[i+2] = (sample_data*)fixed_mpool_alloc(&fmp);
		vp1[i+3] = (sample_data*)fixed_mpool_alloc(&fmp);
	}
	t2 = prof.current();
	for (int i = 0; i+3 < n; i+=4)
	{
		stdal.deallocate(vp0[i+0], sizeof(sample_data));
		stdal.deallocate(vp0[i+1], sizeof(sample_data));
		stdal.deallocate(vp0[i+2], sizeof(sample_data));
		stdal.deallocate(vp0[i+3], sizeof(sample_data));
	}
	t3 = prof.current();
	for (int i = 0; i+3 < n; i+=4)
	{
		fixed_mpool_free(&fmp, vp1[i+0]);
		fixed_mpool_free(&fmp, vp1[i+1]);
		fixed_mpool_free(&fmp, vp1[i+2]);
		fixed_mpool_free(&fmp, vp1[i+3]);
	}
	t4 = prof.current();
	for (int i = 0; i < n; ++i)
	{
		stdal.deallocate(stdal.allocate(1), sizeof(sample_data));
	}
	t5 = prof.current();
	for (int i = 0; i < n; ++i)
	{
		fixed_mpool_free(&fmp, fixed_mpool_alloc(&fmp));
	}
	t6 = prof.current();

	printf("alloc[std=%lld, my=%lld, std/my=%f], free[std=%lld, my=%lld, std/my=%f], alloc+free[std=%lld, my=%lld, std/my=%f]\n"
		, prof.us(t0,t1), prof.us(t1,t2), (double)prof.us(t0,t1)/prof.us(t1,t2)
		, prof.us(t2,t3), prof.us(t3,t4), (double)prof.us(t2,t3)/prof.us(t3,t4)
		, prof.us(t4,t5), prof.us(t5,t6), (double)prof.us(t4,t5)/prof.us(t5,t6)
		);

	fixed_mpool_destroy(&fmp);
}

int main(int argc, char* argv[])
{
	bench(1000000);
	return 0;
}
 

Windows7 + visual C++ 2008

 

time in us

std::allocator(new/delete)

fixed_mpool

fast ratio

alloc

93901

15416

6.091139

free

70657

7374

9.581909

alloc+free

131739

9297

14.170055

Linux

uname:

Linux 2.6.9-78.ELsmp #1 SMP Wed Jul 9 15:46:26 EDT 2008 x86_64 x86_64 x86_64 GNU/Linux

 

time in us

std::allocator(pooled)

fixed_mpool

fast ratio

alloc

92779

26734

3.470450

free

42564

17224

2.471203

alloc+free

50089

9088

5.511554

 

Terark-CTO-雷鹏
关注
专栏目录
Java在多线程方面的内存模型、GC的调优和高效实现的一些经验 Java Memory Management
AI天才研究院
08-07 1165
本文介绍了Java内存管理相关的基础知识以及Java虚拟机在JVM中对内存管理的一些实现方式，包括堆栈、方法区、运行时数据区等内存结构以及不同的内存回收算法的具体实现，并通过分析和总结分析了堆栈溢出、内存泄漏、死锁、内存碎片等常见异常及解决方案。在讨论了内存管理机制以及不同垃圾收集器的优缺点之后，还将介绍如何使用Visual VM工具进行Java内存管理监控和故障排除。最后还会讲述Java在多线程方面的内存模型、GC的调优和高效实现的一些经验。
各种池---内存池的高效实现（C语言）
热门推荐
forever5312的专栏
09-19 2万+
序言 在编程过程中，尤其是对于C语言开发者，其实编程就是在使用内存，不停地变化内存中的数据。当我们想开辟一片新的内存使用时，就会使用malloc实现。但是通过查阅很多资料，发现频繁的使用malloc并不是很好的选择。原因就是如果频繁的申请内存、释放内存，操作系统由于内存管理算法原因，导致会出现内存碎片。其实产生碎片是一件很平常的事情，为何会这样，我想主要是内存利用率与性能的一个平衡。如果操作系统
MemoryPool:使用 C++11 的简单内存池实现
06-13
内存池 使用 C++11 的简单内存池实现。 与 Visual Studio 2015、g++4.8 和 clang++3.4 兼容。 一个使用和文档的例子即将到来。
MemoryPool的简单实现（内存池）
GyafdxIs的专栏
06-27 742
这是可以时常切换的MemoryPool#ifndef MEMORY_POOL #define MEMORY_POOL template class GD_MemoryPool { public: enum{m_nBlock = 32}; GD_MemoryPool(size_t nBlock = m_nBlock) { m_Expand(nBlo
linux下C语言实现的内存池【转】
weixin_34313182的博客
01-11 129
转自：http://blog.chinaunix.net/uid-28458801-id-4254501.html 操作系统：ubuntu10.04 前言：     在通信过程中，无法知道将会接收到的数据的长度，因此开一个固定大小的缓冲区并不合适，开大了，很可能大多数通信都只是几十个自己而已；开小了，又无法处理大数据。因此最好的方法就是创建内存池，根据实际情况，分配合适大小的内存空间。 ...
用C++实现自己的内存池
Bruce Che 的专栏
12-14 1万+
打开浏览器，搜索了下内存管理的概念，百度百科中是这样定义的：内存管理，是指软件运行时对计算机内存资源的分配和使用的技术。其最主要的目的是如何高效，快速的分配，并且在适当的时候释放和回收内存资源。说到内存，与之紧密相联系的一个概念就是指针。回想起上学那会儿，自己对指针是即喜欢，又害怕。因为学好了指针，就可以学好C，继而学好C++，但面对那些晦涩的概念，和程序运行中一些莫名其妙的指针越界、内存泄露……
C++内存池完整代码memory_pool.zip
04-03
在"memory_pool.zip"这个压缩包中，我们可以预期包含了一个实现C++内存池的源码项目。"Makefile"是用于编译和构建项目的配置文件，它定义了如何将源代码文件编译成可执行程序或库。我们可以通过运行`make`命令来编译...
C++ Memory Pool for Apache 2-开源
04-24
内存池（Memory Pool）是一种优化内存分配策略的技术，它在Apache服务器中扮演着至关重要的角色。本文将深入探讨如何在C++编程环境中，利用内存池技术来提升Apache模块的性能。 内存池的基本原理是预先一次性分配一...
Super-memory-pool.rar_super
09-24
“Super memory pool”很可能是一个头文件或源代码文件，包含了内存池的实现，可能包括内存块的管理结构，分配和释放内存的函数等。“TestPrj.txt”则可能是测试项目的说明，指导用户如何构建和运行测试，以验证内存...
Fast Efficient Fixed-Sized Memory Pool
07-02
高效的固定大小内存池实现。对于想在自己引擎或游戏中实现自定义内存分配器的开发者而言是不可多得的参考资料。
linux C 内存池实现
05-16
C语言实现的内存池！j利用默认的内存管理函数new/delete或malloc/free在堆上分配和释放内存会有一些额外的开销。
linux 内存池三方库 用了他你就不需要自己编写内存池了.zip_内存池实现
01-17
linux 内存池三方库 用了他你就不需要自己编写内存池了.zip
linux下内存池实现
01-29
适用于linux服务器开发，提升性能，希望对你有帮助！
Memory Pool
11-29
内存池（memory pool)是代替直接调用malloc/free、new/delete进行内存管理的常用方法，当我们申请内存空间时，首先到我们的内存池中查找合适的内存块，而不是直接向操作系统申请
关于Memory Pool的一些想法及实现
享受开发技术，享受计算机科学
05-22 906
首先引入指针的概念，指针是用来记录地址，并对所指向的地址上所指向类型的数据进行修改。 地址非常关键，将地址转换为指针类型，用指针引用指向该地址的所指向类型的数据。 然后我说说内存池的好处吧。用这种技术的好处有两: 一. 节省空间, 普通的new操作由于需要记住申请的大小, 一般需要更多的空间. 而应用这种技术则不需要额外的空间. 二. 操作速度快, 此种的new和delete操作只是对链表的添
MemoryPool内存池实现
JUST_DO_1122的博客
05-21 331
#ifndef __MEMORY_POOL_H__ #define __MEMORY_POOL_H__ #include <list> #include <malloc.h> template<class T> class MemoryPool { typedef enum{USED, IDLE}STATE_TYPE; typedef struct _ST...
x memory pool c语言 内存池
weixin_30701575的博客
01-24 139
#ifndef X_MEMORY_H #define X_MEMORY_H #include <stdlib.h> #include <stdio.h> #include <memory.h> typedef enum { ErrorUnknown, NoError, ErrorInit, ...
基于C语言的内存池实现
thunderLZM的博客
09-16 1073
设计内存池的目标是为了保证代码高效的运行，通过对申请空间小而申请频繁的对象进行有效管理，减少内存碎片的产生，合理分配管理用户内存，从而减少系统中出现有效空间足够，而无法分配大块连续内存的情况。对于线程，内存，oracle的连接对象等等，这些都是资源，程序中当你创建一个线程或者在堆上申请一块内存时，都涉及到很多系统调用，也是非常消耗CPU的，在把内存放入内存池的同时，要把标志位置为空闲。就是很有可能会造成内存的浪费，原因也很明显，开始分配了一大块内存，不是全部都用得到的。4、内存池的代码实现。
C++实现内存池代码
最新发布
09-01
以下是一个简单的内存池代码实现： ``` #include #define POOL_SIZE 100000 char memory_pool[POOL_SIZE]; int current_position = 0; void *my_malloc(int size) { if (current_position + size > POOL_SIZE)...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值