用于HM6.0代码中的内存池。
相对于(1)的改进：
a.chunk的大小从64bytes开始，到64KB.max_free_chunk[MAX_INDEX] 表示各个size的数目。
const uint32_t chunk_size[MAX_INDEX]={ /* 64 B,128B,256B,320B,512B, */ 1 ,2 ,4 ,5 , 8, /* 1 K,2 K,4 K,8 K,16 K, */ 1<<4,1<<5,1<<6,1<<7,1<<8, /* 32 K,64 K, */ 1<<9,1<<10};//最小内存块BOUNDARY_SIZE(64B)的多少倍
b.预先分配一块大的内存LARGE_BLOCK，大于64KB的从LARGE_BLOCK分配，LARGE_BLOCK不足时再向系统分配。分配时找到一个比要分配的大小 大的MemLargeBlock，从末尾分配空间出去。释放时,空闲的LARGE_BLOCK块以双向链表表示，按照地址从低到高的顺序排列插入链表，并检查能否与前后MemLargeBlock合并。
c.HM6.0大于64KB的全局内存（GlobleLargeMem），未采用b.的策略，而是事先计算好了大小分配好。
源代码：
1 /* 2 ============================================================================ 3 Name : mempool.h 4 Author : mlj 5 Version : 0.1 6 ============================================================================ 7 */ 8 9 #ifndef MEMPOOL_ 10 #define MEMPOOL_ 11 #include <stdint.h> 12 13 #define MEM_ANALYSIS //统计memory的信息 14 #define MAX_INDEX 12 15 16 #define FIX_BLOCK (0x01<<7) //MemBlock 17 #define LARGE_BLOCK (0x01<<6) //MemLargeBlock 18 #define SYSTEM_BLOCK (0x01<<5) //不是从内存池得到的，直接释放给系统 19 #define FREED_BLOCK (0x01<<4) //BlockInfo的低第4bit，表示是否已经释放过了。防止连续重复释放造成混乱 20 21 typedef uint8_t BlockInfo;//BlockInfo 段数据类型,bit7-5表示Block类型, 22 typedef struct MemBlock 23 { 24 uint32_t index;//size 25 uint32_t nfree;//可用的最小内存单元数 26 uint32_t nfirst;//下一个最小可用内存单元编号 27 struct MemBlock* pNextBlock;//下一个index值相同的MemBlock 28 }MemBlock; 29 30 typedef struct MemLargeBlock 31 { 32 char *beginp; /**< pointer to begin of memory */ 33 char *endp; /**< pointer to end of memory [beginp,endp)*/ 34 35 struct MemLargeBlock *prev; 36 struct MemLargeBlock *next; 37 #ifdef MEM_ANALYSIS 38 #endif 39 }MemLargeBlock; 40 41 typedef struct MemPool 42 { 43 MemLargeBlock *head;//双向链表 44 MemBlock *freeblock[MAX_INDEX]; 45 char *pMemory; 46 char *pLargeMemory; 47 }MemPool; 48 49 typedef struct GlobleLargeMem 50 { 51 char *pLarge; 52 char *pLarge_aligned; 53 uint32_t pLarge_size; 54 uint32_t pLarge_aligned_size; 55 uint32_t pLarge_usedsize; 56 uint32_t pLarge_aligned_usedsize; 57 }GlobleLargeMem; 58 extern GlobleLargeMem myGloble; 59 extern MemPool mypool; 60 void* MemPool_malloc(uint32_t in_size); 61 void* MemPool_calloc(uint32_t count,uint32_t size); 62 void MemPool_free(void* _Memory); 63 void MemPool_destroy(MemPool *pool); 64 void MemPool_create(MemPool *pool,uint32_t iPicWith,uint32_t iPicHeght); 65 66 void GlobleLargeMem_Create(GlobleLargeMem* globle_mem,uint32_t iPicWith,uint32_t iPicHeght,uint32_t GOPsize,uint32_t MaxDecPicBuffering); 67 void GlobleLargeMem_Destory(GlobleLargeMem* globle_mem); 68 char* GlobleLargeMem_malloc(uint32_t size); 69 char* GlobleLargeMem_Xmalloc(uint32_t size); 70 void GlobleLargeMem_free(void *p); 71 void GlobleLargeMem_Xfree(void *p); 72 73 #endif
mempool.c
1 /* 2 ============================================================================ 3 Name : mempool.c 4 Author : mlj 5 Version : 0.1 6 ============================================================================ 7 */ 8 #include <stdio.h> 9 #include <stdlib.h> 10 #include <memory.h> 11 #include "mempool.h" 12 13 uint32_t max_free_chunk[MAX_INDEX]={ 14 571+10, 506+10, 6209+10, 324+10, 428+10, 2452+10, 15 749+10, 666+5, 317+5, 315+5, 1, 2};//各块数目 16 const uint32_t chunk_size[MAX_INDEX]={ 17 /* 64 B,128B,256B,320B,512B, */ 18 1 ,2 ,4 ,5 , 8, 19 /* 1 K,2 K,4 K,8 K,16 K, */ 20 1<<4,1<<5,1<<6,1<<7,1<<8, 21 /* 32 K,64 K, */ 22 1<<9,1<<10};//最小内存块BOUNDARY_SIZE(64B)的多少倍 23 24 MemPool mypool; 25 #ifdef MEM_ANALYSIS 26 uint32_t max_used[MAX_INDEX]={0};//达到的用到的chunk数目最大值 27 uint32_t system_malloc=0;//额外从系统malloc的大小 28 int32_t Malloc_Free_check[MAX_INDEX] = {0}; 29 #endif 30 #define BOUNDARY_INDEX 6 31 #define BOUNDARY_SIZE (1 << BOUNDARY_INDEX) // 最小内存块大小64B 32 33 #define CHUNK_HEAD_SIZE ( sizeof(MemBlock*)+ sizeof(uint32_t)+sizeof(BlockInfo) ) 34 #define CHUNK_DATA_SIZE(index) ( BOUNDARY_SIZE*(chunk_size[index])) // 4096*(1<<19) 默认为int 类型，会越界 ( 1<<(chunk_size[index]+BOUNDARY_INDEX)) 35 #define MEMBLOCK_SIZE(index) ( sizeof(MemBlock) + max_free_chunk[(index)]*( CHUNK_HEAD_SIZE + CHUNK_DATA_SIZE(index) ) ) 36 37 #define APR_ALIGN(size, boundary) (((size)+ ((boundary) - 1)) &~((boundary) - 1)) 38 #define LARGE_BLOCK_SIZE (((uint32_t)1<<20)*19) //10M 39 40 void MemBlock_init(MemBlock *block,uint32_t max_free_chunk) 41 { 42 uint32_t i = 0; 43 char *p = NULL; 44 block->nfree = max_free_chunk; 45 block->nfirst = 0; 46 block->pNextBlock = NULL; 47 48 p = (char*)block; 49 ((char*)p) += sizeof(MemBlock); //第0个chunk头地址 50 for(i=0;i<block->nfree;i++) 51 { 52 ( *((MemBlock**)p) ) = (MemBlock*)block; //chunk 头四个字节存放所在的MemBlock的地址 53 ((char*)p) += sizeof(MemBlock*); 54 *((uint32_t*)p) = i+1; //存放下一个可用的chunk的index 55 ((char*)p) += sizeof(uint32_t); 56 *((BlockInfo*)p) = FIX_BLOCK; //设置block类型及index 57 ((char*)p) += sizeof(BlockInfo)+CHUNK_DATA_SIZE(block->index); 58 } 59 } 60 61 _inline void MemLargeBlock_init(MemLargeBlock *block,uint32_t size) 62 { 63 block->beginp = (char *)block; 64 block->endp = ((MemLargeBlock*)block)->beginp + size; 65 block->prev = (MemLargeBlock*)block; 66 block->next = (MemLargeBlock*)block; 67 } 68 69 void* MemLargeBlock_malloc(uint32_t size) 70 { 71 MemLargeBlock *pblock = mypool.head; 72 do 73 { 74 uint32_t blockfreesize = pblock->endp - pblock->beginp - sizeof(MemLargeBlock); 75 if ( (sizeof(MemLargeBlock) + sizeof(BlockInfo) + size) <= blockfreesize) 76 { 77 char* pmalloc = pblock->endp - sizeof(MemLargeBlock) - sizeof(BlockInfo)- size;//分配出去的空间之前有两个字段 78 pblock->endp = pmalloc; 79 MemLargeBlock_init((MemLargeBlock*)pmalloc,(sizeof(MemLargeBlock) + sizeof(BlockInfo) + size)); 80 *( (BlockInfo*)((char*)pmalloc + sizeof(MemLargeBlock) ) ) = LARGE_BLOCK; 81 return ((char*)pmalloc + sizeof(MemLargeBlock) + sizeof(BlockInfo) ); 82 } 83 pblock = pblock->next; 84 } while (pblock != mypool.head); 85 86 if (pblock == mypool.head) //链表中没有这么大的内存 87 { 88 char *pmalloc = (char*) malloc(sizeof(BlockInfo) + size); 89 #ifdef MEM_ANALYSIS 90 system_malloc+=sizeof(BlockInfo) + size;//额外从系统malloc的大小 91 #endif 92 if (pmalloc) 93 { 94 *( (BlockInfo*)((char*)pmalloc ) ) = SYSTEM_BLOCK; 95 return ((char*)pmalloc + sizeof(BlockInfo) ); 96 } 97 else 98 { 99 printf("memory malloc failed!size:%d \n",size); 100 exit(0); 101 } 102 103 } 104 return NULL; 105 } 106 107 void MemLargeBlock_free(void* _Memory) 108 { 109 MemLargeBlock *pblock = (MemLargeBlock*) ( (char*)_Memory - sizeof(MemLargeBlock) - sizeof(BlockInfo) ); 110 MemLargeBlock *pblock2 = mypool.head; 111 pblock->prev = pblock->next =NULL; 112 //空闲块插入链表，并且合并，链表按照地址从低到高的顺序排列 113 if (pblock->beginp>=pblock2->prev->endp)//在最后一个节点之后 114 { 115 if (pblock->beginp == pblock2->prev->endp) 116 { 117 pblock2->prev->endp = pblock->endp; 118 } 119 else//插到最后 120 { 121 pblock->next = pblock2; 122 pblock->prev = pblock2->prev; 123 pblock2->prev->next = pblock; 124 pblock2->prev = pblock; 125 } 126 return; 127 } 128 129 do 130 { 131 if ( pblock->endp<=pblock2->next->beginp )//在pblock2 与 pblock2->next之间 132 { 133 if ( pblock->endp == pblock2->next->beginp && pblock->beginp == pblock2->endp ) //与两者都相邻 134 { 135 pblock2->endp = pblock2->next->endp; //三块合并 136 pblock2->next->next->prev = pblock2; 137 pblock2->next = pblock2->next->next; 138 } 139 else if(pblock->beginp == pblock2->endp ) //与pblock2相邻 140 { 141 pblock2->endp = pblock->endp; //直接加到pblock2之后 142 } 143 else if ( pblock->endp == pblock2->next->beginp ) //与pblock2->next相邻 144 { 145 pblock->endp = pblock2->next->endp;//与pblock2->next合并, 146 pblock2->next->next->prev = pblock; 147 pblock->prev = pblock2; 148 pblock->next = pblock2->next->next; 149 pblock2->next = pblock; 150 } 151 else // 在两者之间，但无相邻 152 { 153 pblock2->next->prev = pblock; 154 pblock->prev = pblock2; 155 pblock->next = pblock2->next; 156 pblock2->next = pblock; 157 } 158 return; 159 } 160 pblock2 = pblock2->next; 161 162 } while (pblock2->next != mypool.head); 163 } 164 void MemPool_create(MemPool *pool,uint32_t iPicWith,uint32_t iPicHeght) 165 { 166 size_t pool_size = 0;// 167 size_t i; 168 char* p = NULL; 169 {//根据图像大小,初始化max_free_chunk[MAX_INDEX] 170 if (iPicWith==416&&iPicHeght==240) 171 { 172 uint32_t temp_free_chunk[MAX_INDEX]={ 173 571+10, 506+10, 6209+10, 324+10, 428+10, 2452+10, 174 749+10, 666+5, 317+5, 315+5, 1, 2};//各块数目(编码20帧测得结果）,再加10或5,随编码帧数所需会有1-2的抖动 175 memcpy(max_free_chunk,temp_free_chunk,MAX_INDEX*sizeof(uint32_t)); 176 } 177 else if (iPicWith==1280&&iPicHeght==720) 178 { 179 uint32_t temp_free_chunk[MAX_INDEX]={ 180 955+10, 2528+10,50717+10, 1283+10, 2548+10,19514+10, 181 4979+10, 4909+5, 2443+5, 2447+5, 4, 2};//各块数目 182 memcpy(max_free_chunk,temp_free_chunk,MAX_INDEX*sizeof(uint32_t)); 183 } 184 else 185 { 186 fprintf(stdout,"Mempool(max_free_chunk) of the pic size does not set!May malloc memory from system\n"); 187 fprintf(stdout,"set macro MEM_ANALYSIS and add the size in MemPool_create() \n"); 188 } 189 } 190 for (i=0;i<MAX_INDEX;i++) 191 { 192 pool_size += MEMBLOCK_SIZE(i); 193 } 194 pool_size += LARGE_BLOCK_SIZE; 195 p = (char *)malloc(pool_size); 196 if(p == NULL) 197 { 198 printf("memory malloc failed!/n"); 199 exit(0); 200 } 201 202 //memset(p,0,pool_size); 203 pool->pMemory = p; 204 205 for (i=0;i<MAX_INDEX;i++) 206 { 207 pool->freeblock[i] = (MemBlock*) (p); 208 pool->freeblock[i]->index = i; 209 MemBlock_init(pool->freeblock[i],max_free_chunk[i]); 210 ((char*)p) += MEMBLOCK_SIZE(i);//注意转为char* 在加偏移 211 } 212 213 pool->pLargeMemory = (char*)p; 214 pool->head = (MemLargeBlock *)(pool->pLargeMemory); 215 MemLargeBlock_init(pool->head,LARGE_BLOCK_SIZE); 216 217 } 218 219 void MemPool_destroy(MemPool *pool) 220 { 221 size_t i; 222 #ifdef MEM_ANALYSIS 223 size_t pool_size = 0; 224 for (i=0;i<MAX_INDEX;i++) 225 { 226 pool_size += MEMBLOCK_SIZE(i); 227 } 228 printf("MemPool analysis:\n"); 229 printf("FIX_BLOCK malloc memory size :%dKB %dM\n",pool_size>>10,pool_size>>20); 230 printf("LARGE_BLOCK malloc memory size :%dKB %dM\n",LARGE_BLOCK_SIZE>>10,LARGE_BLOCK_SIZE>>20); 231 printf("system malloc memory size:%dKB %dM\n",system_malloc>>10,system_malloc>>20); 232 printf("index :"); 233 for (i=0;i<MAX_INDEX/2;i++) 234 { 235 printf("%5d ",i); 236 } 237 printf("\nmax_used:"); 238 for (i=0;i<MAX_INDEX/2;i++) 239 { 240 printf("%5d,",max_used[i]); 241 } 242 printf("\nblock_len:"); 243 for (i=0;i<MAX_INDEX/2;i++) 244 { 245 uint32_t block_len = 0; 246 MemBlock* pblock = NULL; 247 pblock = mypool.freeblock[i]; 248 do 249 { 250 block_len++; 251 }while (pblock=pblock->pNextBlock); 252 printf("%5d ",block_len); 253 } 254 255 printf("\nindex :"); 256 for (i=MAX_INDEX/2;i<MAX_INDEX;i++) 257 { 258 printf("%5d ",i); 259 } 260 printf("\nmax_used:"); 261 for (i=MAX_INDEX/2;i<MAX_INDEX;i++) 262 { 263 printf("%5d,",max_used[i]); 264 } 265 printf("\nblock_len:"); 266 for (i=MAX_INDEX/2;i<MAX_INDEX;i++) 267 { 268 uint32_t block_len = 0; 269 MemBlock* pblock = NULL; 270 pblock = mypool.freeblock[i]; 271 do 272 { 273 block_len++; 274 }while (pblock=pblock->pNextBlock); 275 printf("%5d ",block_len); 276 } 277 for (i=0;i<MAX_INDEX;i++) 278 printf("\nMalloc_Free_check[%d]:%d ",i,Malloc_Free_check[i]); 279 #endif 280 281 for (i=0;i<MAX_INDEX;i++) 282 { 283 MemBlock* pblock = NULL; 284 pblock = mypool.freeblock[i]; 285 while (pblock->pNextBlock) 286 { 287 MemBlock* tmp = pblock->pNextBlock; 288 BlockInfo blocktype = *( (BlockInfo*)((char*)tmp - sizeof(BlockInfo)) ); 289 pblock->pNextBlock = tmp->pNextBlock; 290 if (blocktype&SYSTEM_BLOCK)//来自系统分配 291 { 292 free((char*)tmp - sizeof(BlockInfo)); 293 } 294 } 295 } 296 free(pool->pMemory); 297 pool->pMemory = NULL; 298 } 299 300 void* MemPool_malloc(size_t in_size) 301 { 302 size_t size; 303 size_t index; 304 305 if (in_size > CHUNK_DATA_SIZE(MAX_INDEX-1)) { 306 printf("malloc large size:%d KB\n",in_size>>10); 307 return MemLargeBlock_malloc(in_size); //大于最大固定大小内存块(64K)的处理 308 } 309 /* Find the index for this size 310 */ 311 index = MAX_INDEX; 312 if (in_size <= BOUNDARY_SIZE) 313 { 314 size = BOUNDARY_SIZE; 315 index = 0; 316 } 317 else 318 { 319 size = APR_ALIGN(in_size,BOUNDARY_SIZE); 320 index = 1; //从1开始找index ，while(index<MAX_INDEX) 321 size = size>>BOUNDARY_INDEX;//size = size/BOUNDARY_SIZE,BOUNDARY_SIZE的倍数 322 while(index<MAX_INDEX) 323 { 324 if ( size>(chunk_size[index-1]) && size<=(chunk_size[index]) ) // 325 { 326 break; 327 } 328 index++; 329 } 330 } 331 332 if (index<MAX_INDEX) 333 { 334 MemBlock* pblock = NULL; 335 pblock = mypool.freeblock[index]; 336 //寻找block链表上第一个存在空闲chunk的block 337 do 338 { 339 if (pblock->nfree>0) //找到，退出 340 { 341 break; 342 } 343 else if (pblock->pNextBlock == NULL) //已满，下一memblock又不存在 344 { 345 char *p = NULL; 346 if (max_free_chunk[index] == 0) 347 { 348 max_free_chunk[index] = 1; 349 } 350 351 p = (char*) MemLargeBlock_malloc(MEMBLOCK_SIZE(index));//从LARGE_BLOCK 分配,暂时不释放,destroy pool是释放 352 if (p == NULL) 353 { 354 printf("memory malloc(from large block) failed!/n"); 355 exit(0); 356 } 357 //memset(p,0,MEMBLOCK_SIZE(index)); 358 pblock->pNextBlock = (MemBlock*) (p); 359 pblock->pNextBlock->index = index; 360 pblock=pblock->pNextBlock; 361 MemBlock_init(pblock,max_free_chunk[index]); 362 break; 363 } 364 else 365 { 366 pblock=pblock->pNextBlock; 367 } 368 }while (pblock); 369 370 371 if (pblock->nfree > 0) 372 { 373 uint32_t chunk_id = pblock->nfirst;//待分配的chunk的id 374 char* pchunk = (char*)( pblock ) + sizeof(MemBlock)+(CHUNK_HEAD_SIZE+CHUNK_DATA_SIZE(index))*chunk_id;//第index个chunk的首地址 375 pchunk = pchunk + sizeof(MemBlock*) ;//向后偏移四个字节，指向chunk id 区 376 pblock->nfirst = *((uint32_t*)pchunk) ;//更新下一个可用chunk的id 377 *((uint32_t*)pchunk) = chunk_id; //已分配出去的chunk,chunkid区记下自己的id 378 (char*)pchunk = (char*)pchunk + sizeof(uint32_t) ;//指向BlockInfo 区 379 *((BlockInfo*)pchunk) = (*((BlockInfo*)pchunk))&(~FREED_BLOCK); 380 pblock->nfree--; 381 #ifdef MEM_ANALYSIS 382 { 383 uint32_t used_chunk = 0; 384 uint32_t i=index; 385 Malloc_Free_check[i]++; 386 //for (i=0;i<MAX_INDEX;i++) 387 { 388 MemBlock* pblock = NULL; 389 pblock = mypool.freeblock[i]; 390 used_chunk = 0; 391 do 392 { 393 used_chunk += max_free_chunk[i]-pblock->nfree; 394 }while (pblock=pblock->pNextBlock); 395 if(used_chunk>max_used[i]) 396 max_used[i] = used_chunk; 397 } 398 } 399 #endif 400 return ( (char*)pchunk + sizeof(BlockInfo)); 401 } 402 else 403 { 404 return NULL; 405 } 406 } 407 return NULL; 408 } 409 410 void* MemPool_calloc(uint32_t count,uint32_t size) 411 { 412 void* p =MemPool_malloc(count*size); 413 memset(p,0,count*size); 414 return p; 415 } 416 void MemPool_free(void* _Memory) 417 { 418 BlockInfo blockinfo ; 419 if (_Memory == NULL) 420 { 421 return; 422 } 423 424 blockinfo = *( (BlockInfo*)((char*)_Memory - sizeof(BlockInfo)) ); 425 if (blockinfo&FREED_BLOCK)//已经释放过(已是空闲chunk) 426 { 427 return; 428 } 429 *( (BlockInfo*)((char*)_Memory - sizeof(BlockInfo)) ) = (blockinfo)|(FREED_BLOCK); 430 if( blockinfo & FIX_BLOCK) 431 { 432 MemBlock *pblock = NULL; 433 pblock = *( (MemBlock**)((char*)_Memory - CHUNK_HEAD_SIZE) ); //获取该chunk所在的block地址 434 435 if (pblock->index <MAX_INDEX) 436 {//释放的chunk 挂到最前面，第一个可用的chunk 437 uint32_t chunk_id = pblock->nfirst; 438 char* poffset = ((char*)_Memory - sizeof(uint32_t)- sizeof(BlockInfo)) ;//chunk_id地址 439 pblock->nfirst = * ( (uint32_t*)(poffset) ); 440 * ( (uint32_t*)(poffset) ) = chunk_id ; 441 pblock->nfree++; 442 //memset(_Memory,0,CHUNK_DATA_SIZE(pblock->index));//数据区置0 443 #ifdef MEM_ANALYSIS 444 { 445 uint32_t used_chunk = 0; 446 uint32_t i=pblock->index; 447 Malloc_Free_check[i]--; 448 //for (i=0;i<MAX_INDEX;i++) 449 { 450 MemBlock* pblock = NULL; 451 pblock = mypool.freeblock[i]; 452 used_chunk = 0; 453 do 454 { 455 used_chunk += max_free_chunk[i]-pblock->nfree; 456 }while (pblock=pblock->pNextBlock); 457 if(used_chunk>max_used[i]) 458 max_used[i] = used_chunk; 459 } 460 } 461 #endif 462 } 463 } 464 else if (blockinfo & LARGE_BLOCK) 465 { 466 MemLargeBlock_free(_Memory); 467 } 468 else if (blockinfo & SYSTEM_BLOCK) 469 { 470 free( ((char*)_Memory - sizeof(BlockInfo)) ); 471 } 472 473 474 475 } 476 477 GlobleLargeMem myGloble; 478 479 void GlobleLargeMem_Create(GlobleLargeMem* globle_mem,uint32_t iPicWith,uint32_t iPicHeght,uint32_t GOPsize,uint32_t MaxDecPicBuffering) 480 { 481 globle_mem->pLarge_size = 0; 482 globle_mem->pLarge_usedsize = 0; 483 globle_mem->pLarge_aligned_size = 0; 484 globle_mem->pLarge_aligned_usedsize = 0; 485 486 487 if( (globle_mem->pLarge = (char*)malloc(globle_mem->pLarge_size)) == NULL) 488 { 489 printf("memory malloc failed!\n"); 490 exit(0); 491 } 492 memset(globle_mem->pLarge,0,globle_mem->pLarge_size); 493 if( (globle_mem->pLarge_aligned = (char*)malloc(globle_mem->pLarge_aligned_size)) == NULL) 494 { 495 printf("memory malloc failed!\n"); 496 exit(0); 497 } 498 memset(globle_mem->pLarge_aligned,0,globle_mem->pLarge_aligned_size); 499 #ifdef MEM_ANALYSIS 500 printf("Globle large mem size :%d byets,%d KB,%d M\n",globle_mem->pLarge_size,globle_mem->pLarge_size>>10,globle_mem->pLarge_size>>20); 501 printf("Globle large aligned mem size:%d byets,%d KB,%d M\n",globle_mem->pLarge_aligned_size,globle_mem->pLarge_aligned_size>>10,globle_mem->pLarge_aligned_size>>20); 502 #endif 503 } 504 505 void GlobleLargeMem_Destory(GlobleLargeMem* globle_mem) 506 { 507 #ifdef MEM_ANALYSIS 508 printf("Globle large mem size :%5d byets,%5d KB,%5d M Free:%5dbytes\n",globle_mem->pLarge_size,globle_mem->pLarge_size>>10,globle_mem->pLarge_size>>20,globle_mem->pLarge_size-globle_mem->pLarge_usedsize); 509 printf("Globle large aligned mem size:%5d byets,%5d KB,%5d M Free:%5dbytes\n",globle_mem->pLarge_aligned_size,globle_mem->pLarge_aligned_size>>10,globle_mem->pLarge_aligned_size>>20,globle_mem->pLarge_aligned_size-globle_mem->pLarge_aligned_usedsize); 510 #endif 511 512 if (globle_mem->pLarge) 513 { 514 free(globle_mem->pLarge); 515 globle_mem->pLarge = NULL; 516 } 517 if (globle_mem->pLarge_aligned) 518 { 519 free(globle_mem->pLarge_aligned); 520 globle_mem->pLarge_aligned = NULL; 521 } 522 } 523 524 char* GlobleLargeMem_malloc(uint32_t size) 525 { 526 if (size<=(myGloble.pLarge_size - myGloble.pLarge_usedsize)) 527 { 528 char *p = (char*)(myGloble.pLarge)+myGloble.pLarge_usedsize; 529 myGloble.pLarge_usedsize += size; 530 return p; 531 } 532 else 533 { 534 printf("Large_size memory is not enough!Need:%d bytes\n",size-(myGloble.pLarge_size - myGloble.pLarge_usedsize)); 535 return NULL; 536 } 537 } 538 539 char* GlobleLargeMem_Xmalloc(uint32_t size) 540 { 541 char *p = (char*)(myGloble.pLarge_aligned)+myGloble.pLarge_aligned_usedsize; 542 #if DATA_ALIGN 543 uint32_t offset = ( 32 - p%32 )%32; 544 #else 545 uint32_t offset =0; 546 #endif 547 size += offset; 548 if (size<=(myGloble.pLarge_aligned_size - myGloble.pLarge_aligned_usedsize)) 549 { 550 myGloble.pLarge_aligned_usedsize += size; 551 return (p+offset); 552 } 553 else 554 { 555 printf("Largealigned_size memory is not enough!Need:%d bytes\n",size-(myGloble.pLarge_aligned_size - myGloble.pLarge_aligned_usedsize)); 556 return NULL; 557 } 558 } 559 560 void GlobleLargeMem_free(void *p) 561 { 562 563 } 564 void GlobleLargeMem_Xfree(void *p) 565 { 566 567 } 568 569 570 int main() 571 { 572 char* p1[10]; 573 int i; 574 MemPool_create(&mypool,416,240); 575 for (i=0;i<6;i++) 576 { 577 p1[i]=(char*) MemPool_malloc(1024<<i); 578 } 579 for (i=0;i<6;i++) 580 { 581 MemPool_free(p1[i]); 582 p1[i] = NULL; 583 } 584 585 MemPool_destroy(&mypool); 586 return 0; 587 }