热门标签 | HotTags
当前位置:  开发笔记 > 编程语言 > 正文

单片机(不基于os)下如何实现简单的内存管理(malloc,realloc和free函数的重新实现)

实现的原理是将内存分成小的片段进行管理,代码如下:[cpp]viewplaincopy#defineMEM_BLOCK_SIZE4096#defineMEM_LARGE_BLOCK_TH


实现的原理是将内存分成小的片段进行管理,代码如下:

[cpp] view plaincopy
  1. #define MEM_BLOCK_SIZE 4096  
  2. #define MEM_LARGE_BLOCK_THRESHOLD       40960       //>MEM_LARGE_BLOCK_THRESHOLD :requested size is large block   
  3. #define MEM_BASE_ADDRESS                (0x90000000)  
  4. #define MEM_ALLOC_TABLE_FIRST_ENTRY 0  
  5. #define MAX_MEM_SIZE 7*1024*1024  
  6. #define MEM_ALLOC_TABLE_SIZE    (MAX_MEM_SIZE/MEM_BLOCK_SIZE)  
  7. static INT16 memory_map[MEM_ALLOC_TABLE_SIZE];  
  8. static char isMemoryManagementReady=0;  
  9. void *memset(void *s, int c, size_t count)  
  10. {  
  11.     char *xs = s;  
  12.     while (count--)  
  13.         *xs++ = c;  
  14.     return s;  
  15. }  
  16.   
  17. INT32 ssd_mem_init(void)  
  18. {  
  19.     memset(memory_map, 0, sizeof(memory_map));  
  20.     isMemoryManagementReady=1;  
  21. }  
  22. INT16   ssd_mem_percentage_used()  
  23. {  
  24.     int used=0;  
  25.     int i;  
  26.     for(i=0;i
  27.     {  
  28.         if(memory_map[i])  
  29.         {  
  30.             used++;  
  31.         }  
  32.     }  
  33.     return used*100/MEM_ALLOC_TABLE_SIZE;  
  34. }  
  35. //return -1:FAIL  
  36. //>=0:   return allocated address offset  
  37. INT32 ssd_mem_malloc(UINT32 size)  
  38. {  
  39.     int offset=0;  
  40.     int startEntry=MEM_ALLOC_TABLE_FIRST_ENTRY;  
  41.     int nmemb;  
  42.     int i;  
  43.     if(!isMemoryManagementReady)  
  44.     {  
  45.            ssd_mem_init();  
  46.     }  
  47.       
  48.     if(size==0)  
  49.     {  
  50.         return -1;  
  51.     }  
  52.     nmemb=size/MEM_BLOCK_SIZE;  
  53.     if(size%MEM_BLOCK_SIZE)  
  54.     {  
  55.         nmemb++;  
  56.     }  
  57.           
  58.     if(size > MEM_LARGE_BLOCK_THRESHOLD)  
  59.     {  
  60.         for(offset=startEntry;offset
  61.         {  
  62.             if(!memory_map[offset])   
  63.             {  
  64.                 int vacantSize=0;  
  65.                 for(vacantSize=0;vacantSize
  66.                 if(vacantSize==nmemb)  
  67.                 {  
  68.                     for(i=0;i
  69.                     {  
  70.                         memory_map[offset+i]=nmemb;  
  71.                     }  
  72.                     return (offset*MEM_BLOCK_SIZE);  
  73.                 }  
  74.             }  
  75.         }  
  76.     }  
  77.     else  
  78.     {  
  79.         for(offset=MEM_ALLOC_TABLE_SIZE-1;offset>=0;offset--)  
  80.         {     
  81.             if(!memory_map[offset] && ((offset+nmemb)<=MEM_ALLOC_TABLE_SIZE))//search start of vacant block  
  82.             {  
  83.                 
  84.                 int vacantSize=0;  
  85.                 for(vacantSize=0;vacantSize
  86.                 if(vacantSize==nmemb)  
  87.                 {  
  88.                     for(i=0;i
  89.                     {  
  90.                         memory_map[offset+i]=nmemb;  
  91.                     }  
  92.                     return (offset*MEM_BLOCK_SIZE);  
  93.                 }  
  94.             }  
  95.         }  
  96.     }  
  97.     puts("malloc size erorr=");  
  98.     putInt32(size);  
  99.     return -1;  
  100. }  
  101. //return 0:OK  
  102. //return 1:Out of bound  
  103. INT32 ssd_mem_free(INT32 offset)  
  104. {  
  105.     int i;  
  106.     if(!isMemoryManagementReady)  
  107.     {  
  108.         ssd_mem_init();  
  109.         return 1;  
  110.     }  
  111.     if(offset
  112.     {  
  113.         int index=offset/MEM_BLOCK_SIZE;  
  114.         int nmemb=memory_map[index];  
  115.         for(i=0;i
  116.         {  
  117.             memory_map[index+i]=0;  
  118.         }  
  119.         return 0;  
  120.     }  
  121.     else  
  122.     {  
  123.        return 1;//out of bound  
  124.     }  
  125. }  
  126. void free(void *ptr)  
  127. {  
  128.     if(ptr==NULL)  
  129.         return;  
  130.     INT32 offset;  
  131.     offset=ptr-MEM_BASE_ADDRESS;  
  132.     ssd_mem_free(offset);     
  133. }  
  134. void * malloc(UINT32 size)  
  135. {  
  136.     INT32 offset;  
  137.     offset=ssd_mem_malloc(size);  
  138.     if(offset==-1)  
  139.         {  
  140.         return NULL;  
  141.         }  
  142.     else  
  143.         return MEM_BASE_ADDRESS+offset;  
  144.       
  145. }  
  146.   
  147. void *realloc(void *ptr,UINT32 size)  
  148. {  
  149.     INT32 offset;  
  150.     offset=ssd_mem_malloc(size);  
  151.     if(offset==-1)  
  152.         {  
  153.         puts("realloc error/n");  
  154.         return NULL;  
  155.         }  
  156.     else  
  157.         {  
  158.             memcpy((void*)(MEM_BASE_ADDRESS+offset),ptr,size);  
  159.             free(ptr);  
  160.             return MEM_BASE_ADDRESS+offset;       
  161.         }  



推荐阅读
author-avatar
牧高风_457
这个家伙很懒,什么也没留下!
PHP1.CN | 中国最专业的PHP中文社区 | DevBox开发工具箱 | json解析格式化 |PHP资讯 | PHP教程 | 数据库技术 | 服务器技术 | 前端开发技术 | PHP框架 | 开发工具 | 在线工具
Copyright © 1998 - 2020 PHP1.CN. All Rights Reserved | 京公网安备 11010802041100号 | 京ICP备19059560号-4 | PHP1.CN 第一PHP社区 版权所有