zoukankan html css js c++ java

HM 内存池设计(2) HM6.0内存池设计

用于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 }

查看全文

相关阅读:
web自动化中的上传操作
 HTTP协议
 创建一个get测试
 下载安装
 unittest 介绍
 selenium常用操作
 video视频操作
 调用JavaScript
下拉框操作
 弹窗操作

原文地址：https://www.cnblogs.com/mlj318/p/2540488.html