malloc.c 4.7 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226
  1. #include "malloc.h"
  2. #if 0
  3. //内存池(32字节对齐)
  4. __align(32) uint8_t mem1base[MEM1_MAX_SIZE]; //内部SRAM内存池
  5. __align(32) uint8_t mem2base[MEM2_MAX_SIZE] __attribute__((at(0X68000000))); //外部SRAM内存池
  6. //内存管理表
  7. uint16_t mem1mapbase[MEM1_ALLOC_TABLE_SIZE]; //内部SRAM内存池MAP
  8. uint16_t mem2mapbase[MEM2_ALLOC_TABLE_SIZE] __attribute__((at(0X68000000+MEM2_MAX_SIZE))); //外部SRAM内存池MAP
  9. //内存管理参数
  10. const uint32_t memtblsize[SRAMBANK]={MEM1_ALLOC_TABLE_SIZE,MEM2_ALLOC_TABLE_SIZE}; //内存表大小
  11. const uint32_t memblksize[SRAMBANK]={MEM1_BLOCK_SIZE,MEM2_BLOCK_SIZE}; //内存分块大小
  12. const uint32_t memsize[SRAMBANK]={MEM1_MAX_SIZE,MEM2_MAX_SIZE}; //内存总大小
  13. //内存管理控制器
  14. struct _m_mallco_dev mallco_dev=
  15. {
  16. my_mem_init, //内存初始化
  17. my_mem_perused, //内存使用率
  18. mem1base,mem2base, //内存池
  19. mem1mapbase,mem2mapbase, //内存管理状态表
  20. 0,0, //内存管理未就绪
  21. };
  22. //复制内存
  23. //*des:目的地址
  24. //*src:源地址
  25. //n:需要复制的内存长度(字节为单位)
  26. void mymemcpy(void *des,void *src,uint32_t n)
  27. {
  28. uint8_t *xdes=des;
  29. uint8_t *xsrc=src;
  30. while(n--)*xdes++=*xsrc++;
  31. }
  32. //设置内存
  33. //*s:内存首地址
  34. //c :要设置的值
  35. //count:需要设置的内存大小(字节为单位)
  36. void mymemset(void *s,uint8_t c,uint32_t count)
  37. {
  38. uint8_t *xs = s;
  39. while(count--)*xs++=c;
  40. }
  41. //内存管理初始化
  42. //memx:所属内存块
  43. void my_mem_init(uint8_t memx)
  44. {
  45. mymemset(mallco_dev.memmap[memx], 0,memtblsize[memx]*2);//内存状态表数据清零
  46. mymemset(mallco_dev.membase[memx], 0,memsize[memx]); //内存池所有数据清零
  47. mallco_dev.memrdy[memx]=1; //内存管理初始化OK
  48. }
  49. //获取内存使用率
  50. //memx:所属内存块
  51. //返回值:使用率(0~100)
  52. uint8_t my_mem_perused(uint8_t memx)
  53. {
  54. uint32_t used=0;
  55. uint32_t i;
  56. for(i=0;i<memtblsize[memx];i++)
  57. {
  58. if(mallco_dev.memmap[memx][i])used++;
  59. }
  60. return (used*100)/(memtblsize[memx]);
  61. }
  62. //内存分配(内部调用)
  63. //memx:所属内存块
  64. //size:要分配的内存大小(字节)
  65. //返回值:0XFFFFFFFF,代表错误;其他,内存偏移地址
  66. uint32_t my_mem_malloc(uint8_t memx,uint32_t size)
  67. {
  68. signed long offset=0;
  69. uint32_t nmemb; //需要的内存块数
  70. uint32_t cmemb=0;//连续空内存块数
  71. uint32_t i;
  72. if(!mallco_dev.memrdy[memx])mallco_dev.init(memx);//未初始化,先执行初始化
  73. if(size==0)
  74. return 0XFFFFFFFF;//不需要分配
  75. nmemb=size/memblksize[memx]; //获取需要分配的连续内存块数
  76. if(size%memblksize[memx])nmemb++;
  77. for(offset=memtblsize[memx]-1;offset>=0;offset--)//搜索整个内存控制区
  78. {
  79. if(!mallco_dev.memmap[memx][offset])cmemb++;//连续空内存块数增加
  80. else cmemb=0; //连续内存块清零
  81. if(cmemb==nmemb) //找到了连续nmemb个空内存块
  82. {
  83. for(i=0;i<nmemb;i++) //标注内存块非空
  84. {
  85. mallco_dev.memmap[memx][offset+i]=nmemb;
  86. }
  87. return (offset*memblksize[memx]);//返回偏移地址
  88. }
  89. }
  90. return 0XFFFFFFFF;//未找到符合分配条件的内存块
  91. }
  92. //释放内存(内部调用)
  93. //memx:所属内存块
  94. //offset:内存地址偏移
  95. //返回值:0,释放成功;1,释放失败;
  96. uint8_t my_mem_free(uint8_t memx,uint32_t offset)
  97. {
  98. int i;
  99. if(!mallco_dev.memrdy[memx])//未初始化,先执行初始化
  100. {
  101. mallco_dev.init(memx);
  102. return 1;//未初始化
  103. }
  104. if(offset<memsize[memx])//偏移在内存池内.
  105. {
  106. int index=offset/memblksize[memx]; //偏移所在内存块号码
  107. int nmemb=mallco_dev.memmap[memx][index]; //内存块数量
  108. for(i=0;i<nmemb;i++) //内存块清零
  109. {
  110. mallco_dev.memmap[memx][index+i]=0;
  111. }
  112. return 0;
  113. }
  114. else
  115. return 2;//偏移超区了.
  116. }
  117. //释放内存(外部调用)
  118. //memx:所属内存块
  119. //ptr:内存首地址
  120. void myfree(uint8_t memx,void *ptr)
  121. {
  122. uint32_t offset;
  123. if(ptr==NULL)return;//地址为0.
  124. offset=(uint32_t)ptr-(uint32_t)mallco_dev.membase[memx];
  125. my_mem_free(memx,offset); //释放内存
  126. }
  127. //分配内存(外部调用)
  128. //memx:所属内存块
  129. //size:内存大小(字节)
  130. //返回值:分配到的内存首地址.
  131. void *mymalloc(uint8_t memx,uint32_t size)
  132. {
  133. uint32_t offset;
  134. offset=my_mem_malloc(memx,size);
  135. if(offset==0XFFFFFFFF)return NULL;
  136. else return (void*)((uint32_t)mallco_dev.membase[memx]+offset);
  137. }
  138. //重新分配内存(外部调用)
  139. //memx:所属内存块
  140. //*ptr:旧内存首地址
  141. //size:要分配的内存大小(字节)
  142. //返回值:新分配到的内存首地址.
  143. void *myrealloc(uint8_t memx,void *ptr,uint32_t size)
  144. {
  145. uint32_t offset;
  146. offset=my_mem_malloc(memx,size);
  147. if(offset==0XFFFFFFFF)return NULL;
  148. else
  149. {
  150. mymemcpy((void*)((uint32_t)mallco_dev.membase[memx]+offset),ptr,size); //拷贝旧内存内容到新内存
  151. myfree(memx,ptr); //释放旧内存
  152. return (void*)((uint32_t)mallco_dev.membase[memx]+offset); //返回新内存首地址
  153. }
  154. }
  155. #endif