嵌入式（标准C环境下）下通用的内存池的实现---C文件

最新推荐文章于 2023-10-22 10:10:42 发布
最新推荐文章于 2023-10-22 10:10:42 发布
阅读量1.2k 收藏 4
点赞数
分类专栏： Garbage Collector 文章标签： 嵌入式 c null include
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/turui/article/details/3135072
版权
  1. #include "avit_memory_pool.h"
  2. #include "avit_oc_print.h"
  4. static UINT32 peak_memory_use = 0;
  5. static UINT32 now_memory_use = 0;
  7. static BYTE* pool_adr = NULL;
  8. static MemNode* pool_link = NULL;
  10. static MemNode* memory_pool_first_fitting(UINT32 size);
  12. void memory_pool_dump()
  13. {
  14.     MemNode* temp_node = pool_link;
  15.     temp_node = pool_link;
  16.     while(TRUE)
  17.     {
  18.         if( temp_node == NULL ) break;
  20.         oc_println("[0x%08X][0x%08X][0x%08X][0x%08X][%d][%d]",
  21.             temp_node->last,
  22.             temp_node,
  23.             temp_node->next,
  24.             temp_node->addr,
  25.             temp_node->size,
  26.             temp_node->used
  27.             );
  28.         temp_node = temp_node->next ;       
  29.     }
  30. }
  32. UINT32 memory_pool_get_available_size()
  33. {
  34.     return (MEMORY_POOL_SIZE-now_memory_use);
  35. }
  37. UINT32 memory_pool_get_peak_use()
  38. {
  39.     return peak_memory_use;
  40. }
  42. UINT32 memory_pool_get_now_use()
  43. {
  44.     return now_memory_use;
  45. }
  48. INT32 memory_pool_init()
  49. {
  50.     if(!MEMORY_POOL_ENABLE) return J_SUCCESS;
  52.     memory_pool_release();
  54.     oc_println("memory pool initialized");
  55.     oc_println("memory pool size is %d",MEMORY_POOL_SIZE);
  57.     if(J_OSP_GetAvailableMemorySize() < MEMORY_POOL_SIZE )
  58.     {
  59.         oc_println("There is no enough memor for oc");
  60.         return J_FAILURE;
  61.     }
  62.     
  63.     // 分配池所要用到的内存
  64.     pool_adr = J_OSP_AllocateMemory(MEMORY_POOL_SIZE);
  65.     if(pool_adr == NULL) return J_FAILURE;
  67.     // 建立池的第一个结点
  68.     pool_link = (MemNode*)J_OSP_AllocateMemory(sizeof(MemNode));
  69.     pool_link->addr = pool_adr;
  70.     pool_link->used = FALSE;
  71.     pool_link->last = NULL;
  72.     pool_link->next = NULL;
  73.     pool_link->size = MEMORY_POOL_SIZE;
  75.     if(MEMORY_POOL_COUNTER_ENABLE)
  76.     {
  77.         peak_memory_use = 0;    
  78.         now_memory_use = 0;
  79.     }
  81.     return J_SUCCESS;
  82. }
  84. static MemNode* memory_pool_first_fitting(UINT32 size)
  85. {
  86.     MemNode* this_node = NULL;
  87.     MemNode* temp_node = pool_link; 
  88.     while(TRUE)
  89.     {
  90.         if(temp_node == NULL) break;
  92.         if( (temp_node->size >= size) && (temp_node->used == FALSE) )
  93.         {
  94.             this_node = temp_node;
  95.             break;
  96.         }
  97.         temp_node = temp_node->next;
  98.     }   
  100.     return this_node;
  101. }
  104. void* memory_pool_malloc(UINT32 size)
  105. {
  106.     // 目前采用首次拟合
  107.     MemNode* this_node = NULL;
  108.     UINT32 nee_size = size;
  109.     if(!MEMORY_POOL_ENABLE) return J_OSP_AllocateMemory(size);
  111.     if(size == 0)
  112.     {
  113.         oc_println("abnormal memeory malloc size is 0");
  114.         return NULL;
  115.     }
  117.     if( (nee_size % 4) != 0 )
  118.         nee_size += (4-(nee_size%4));
  119.     
  120.     this_node = memory_pool_first_fitting(nee_size);
  121.     if(this_node == NULL)
  122.     {
  123.         oc_println("malloc memeory faild,size is %d",size);
  124.         return NULL;
  125.     }
  126.     size = nee_size;
  128.     if(this_node->size == size)
  129.     {
  130.         this_node->used = TRUE;
  132.         if(MEMORY_POOL_COUNTER_ENABLE)
  133.         {
  134.             now_memory_use += size;
  135.             if(now_memory_use >= peak_memory_use) peak_memory_use = now_memory_use;
  136.         }
  138.         return (void*)this_node->addr;
  139.     }
  141.     // 操作链表关系
  142.     {       
  143.         MemNode* last_node = this_node->last;
  144.         MemNode* new_node = (MemNode *)J_OSP_AllocateMemory(sizeof(MemNode));
  146.         if( this_node == pool_link ) 
  147.             pool_link = new_node;
  148.         else
  149.             last_node->next = new_node;
  151.         // 处理 new node
  152.         new_node->addr = this_node->addr;
  153.         new_node->used = TRUE;
  154.         new_node->last = last_node;
  155.         new_node->next = this_node;
  156.         new_node->size = size;
  158.         // 处理 this node
  159.         this_node->addr += size;
  160.         this_node->last = new_node; 
  161.         this_node->size -= size;
  163.         if(MEMORY_POOL_COUNTER_ENABLE)
  164.         {
  165.             now_memory_use += size;
  166.             if(now_memory_use >= peak_memory_use) peak_memory_use = now_memory_use;
  167.         }
  169.         return (void*)new_node->addr;
  170.     }
  171. }
  173. void memory_pool_free(void* pAddr)
  174. {
  175.     // 找到 pAddr 所在的 memnode
  176.     MemNode* this_node = NULL;
  177.     MemNode* temp_node = pool_link;
  178.     if(!MEMORY_POOL_ENABLE)
  179.     {
  180.         J_OSP_FreeMemory(pAddr);
  181.         return;
  182.     }
  184.     while(TRUE)
  185.     {
  186.         if( temp_node == NULL ) break;
  187.         if( temp_node->addr == pAddr)
  188.         {
  189.             this_node = temp_node;
  190.             break;
  191.         }
  192.         temp_node = temp_node->next ;
  193.     }
  194.     if(this_node == NULL)
  195.     {
  196.         oc_println("abnormal memory free!!");
  197.         return;
  198.     }
  200.     this_node->used = FALSE;
  201.     if(MEMORY_POOL_COUNTER_ENABLE) now_memory_use -= this_node->size;                                   
  203.     // 处理链表关系
  204.     {
  205.         MemNode* last_node = this_node->last;       
  206.         MemNode* next_node = this_node->next;
  207.         
  208.         // 第一次合并，和前一个块(last_node)进行合并
  209.         if(last_node != NULL)
  210.         {
  211.             // 与 last_node 合并
  212.             if( last_node->used == FALSE)
  213.             {               
  214.                 last_node->size += this_node->size;
  215.                 last_node->next = next_node;
  217.                 if(next_node != NULL)
  218.                     next_node->last = last_node;
  220.                 // 释放 this_node
  221.                 J_OSP_FreeMemory(this_node);
  222.                 this_node = NULL;
  223.             }           
  224.         }       
  226.         // 第二次合并，需要判断前面合并过没
  227.         if(this_node == NULL)// 已经和前面合并过了
  228.         {
  229.             // 判断是否需要和下一个块合并
  230.             if(next_node != NULL)
  231.             {
  232.                 if(next_node->used == FALSE) // next node 是空闲的
  233.                 {
  234.                     // 处理 last node                 
  235.                     last_node->next = next_node->next;
  236.                     last_node->size += next_node->size;
  238.                     // 处理 next_node;
  239.                     if(next_node->next != NULL)                 
  240.                         next_node->next->last = last_node;                  
  242.                     // 清除next_node
  243.                     J_OSP_FreeMemory(next_node);
  244.                     next_node = NULL;
  245.                 }
  246.             }
  247.         }
  248.         else // 没合并过
  249.         {
  250.             // 判断是否需要和下一个块合并
  251.             if(next_node != NULL)
  252.             {
  253.                 if(next_node->used == FALSE) // next node 是空闲的
  254.                 {                   
  255.                     this_node->next = next_node->next;
  256.                     this_node->size += next_node->size;
  258.                     if(next_node->next != NULL)                 
  259.                         next_node->next->last = this_node;                  
  261.                     J_OSP_FreeMemory(next_node);
  262.                     next_node = NULL;                   
  263.                 }
  264.             }
  265.         }           
  266.     }
  267. }
  269. void memory_pool_release()
  270. {
  271.     if(!MEMORY_POOL_ENABLE) return;
  272.     memory_pool_clear();
  274.     // 清除第一个结点
  275.     if(pool_link != NULL)
  276.     {   
  277.         J_OSP_FreeMemory(pool_link);
  278.         pool_link = NULL;
  279.     }
  281.     if( pool_adr != NULL)
  282.     {
  283.         J_OSP_FreeMemory(pool_adr);
  284.         pool_adr = NULL;
  285.     }       
  286.     if(MEMORY_POOL_COUNTER_ENABLE)
  287.         oc_println("peak memory use %d",peak_memory_use);   
  288.     peak_memory_use = 0;    
  289.     now_memory_use = 0;
  290.     oc_println("memory pool released.");
  291. }
  293. void memory_pool_clear()
  294. {
  295.     // 释放池的管理内存，删到只剩下一个结点
  296.     UINT32 garbage_count = 0;
  297.     MemNode* temp = NULL;
  299.     if(pool_link == NULL) return;
  300.     if(pool_link->next == NULL) return;
  302.     while(TRUE)
  303.     {       
  304.         temp = pool_link;
  305.         pool_link = pool_link->next;        
  306.         J_OSP_FreeMemory(temp);
  307.         temp = NULL;
  308.         if(MEMORY_POOL_COUNTER_ENABLE) garbage_count++;                                 
  309.         if(pool_link->next == NULL) break;
  310.     }
  312.     pool_link->addr = pool_adr;
  313.     pool_link->used = FALSE;
  314.     pool_link->last = NULL;
  315.     pool_link->next = NULL;
  316.     pool_link->size = MEMORY_POOL_SIZE;
  317.     now_memory_use = 0;
  318.     if(MEMORY_POOL_COUNTER_ENABLE) oc_println("memory garbage count is %d",garbage_count);  
  319. }
 
一个高效的内存池实现
把握自己。
12-14 1781
在高效C++编程中看到一个不错的内存池实现方案，这里共享下，大家看看有什么不足。 代码很简单，如下： template class CMemoryPool {     public:         enum { EXPANSION_SIZE = 32};         CMemoryPool(unsigned int nItemCount = EXPANSION_SI
嵌入式系统/ARM技术中的μC/OS-II下通用驱动框架的设计与实现
12-05
《μC/OS-II下通用驱动框架的设计与实现》 嵌入式系统是现代电子设备中的关键组成部分，尤其是在工业自动化、物联网以及消费电子产品等领域。在这些系统中，嵌入式实时操作系统（RTOS）如μC/OS-II起着至关重要的...
嵌入式（标准C环境下）下通用的内存池的实现---后记（使用）
涂睿的专栏
10-24 1192
// 将常用的 malloc 和 free 替换成池提供的内存访问函数 void* memory_pool_malloc(UINT32 size);void memory_pool_free(void* pAddr);// 记得初在应用最开始始化和最后释放 memory_pool_init() memory_pool_release();// 在嵌入式环境下
STM32动态内存分配
young45的专栏
03-19 5586
原文：http://www.openedv.com/posts/list/17718.htm #ifndef __MALLOC_H #define __MALLOC_H #include "sys.h" //////////////////////////////////////////////////////////////////////////////////  //本程序
嵌入式（标准C环境下）下通用的内存池的实现---前言
涂睿的专栏
10-24 1674
/*对内存池的需求分析：   我们希望我们开发的某个应用可以使用以一块固定的内存空间   这块内存空间是一开始申请好的，   所有的内存使用都是在这块空间内完成，可以避免和其他应用的内存使用相互冲突      可以对应用使用的内存情况进行部分统计   可以在应用退出后自动对内存进行回收（我们假设用户的习编程惯是不良好的，有可能产生内存泄露）尤
嵌入式算法：C语言内存池设计和实现
KPer_Yang的博客
08-04 773
嵌入式算法：C语言内存池设计和实现
嵌入式实时操作系统μC/OS-II下通用驱动框架的设计
07-30
μC/OS-II提供了一系列基础功能，包括任务管理、信号量、邮箱、消息队列、事件、时间管理和内存管理，但不包含设备管理和文件系统。因此，为了满足实际应用需求，需要对μC/OS-II进行扩展，特别是设备管理方面。 ...
μC/OS-II嵌入式系统中通用驱动框架设计与实现
"嵌入式系统/ARM技术中的μC/OS-II下通用驱动框架的设计与实现" 嵌入式系统是现代电子设备的核心组成部分，尤其是在物联网、工业自动化和消费电子产品中。在这些系统中，使用嵌入式实时操作系统（RTOS）如μC/OS-II...
嵌入式系统/ARM技术中的在MOTOROLAA68K系列MCU上移植μC/OS-II的实现
10-22
这个过程中，主要涉及三个关键文件：C语言文件`OS_CPU32.C`、头文件`OS_CPU32.H`和汇编文件`OS_CPU32.ASM`。`OS_CPU32.C`包含了与特定CPU相关的C语言函数实现，`OS_CPU32.H`定义了硬件相关的类型和常量，而`OS_CPU32...
嵌入式系统/ARM技术中的在AndesCore N1033A-S处理器实现μC/OS-II的移植
10-21
以及os_cpu_c.c文件，实现与处理器相关的C函数。 3. 调整μC/OS-II源代码：根据N1033A-S的架构，可能需要修改μC/OS-II的部分源代码，例如中断服务例程、任务调度器和内存管理。 4. 测试和调试：编译、加载并测试...
C语言内存池
08-30
自己实现的C语言内存池，代码量少，支持自定义内存池数量，大小。使用非常简单，支持多线程
嵌入式linux内存池,内存池架构 · tboox/tbox Wiki · GitHub
weixin_28717467的博客
05-03 317
TBOX的内存管理模型，参考了linux kernel的内存管理机制，并在其基础上做了一些改进和优化。内存整体架构large_pool整个内存分配的最底层，都是基于large_pool的大块内存分配池，类似于linux的基于page的分配管理，不过有所不同的是，large_pool并没有像linux那样使用buddy算法进行(2^N)*page进行分配，这样如果需要2.1m的内存，需要分配4m的内...
嵌入式（标准C环境下）下通用的内存池的实现---头文件
涂睿的专栏
10-24 1026
#ifndef __AVIT_OC_GEN_H__ #define __AVIT_OC_GEN_H__ #ifdef _MSC_VER     #include "wtypes.h"      #include "stdio.h" #endif #include "j_gendef.h" #include "avit_oc_config.h"
RT-Thread 05内存管理
dsf031411的博客
10-05 3776
在计算系统中，变量、中间数据一般存放在系统存储空间中，只有在实际使用时才将它们从存储空间调入到中央处理器内部进行运算。通常存储空间可以分为两种：内部存储空间和外部存储空间。内部存储空间访问速度比较快，能够按照变量地址随机地访问，也就是我们通常所说的RAM（随机存储器），或电脑的内存；而外部存储空间内所保存的内容相对来说比较固定，即使掉电后数据也不会丢失，这就是通常所讲的ROM（只读存储器），也可以把
嵌入式linux内存池,Linux 内存池源码浅析
weixin_39713335的博客
05-03 142
内存池(Memery Pool)技术是在真正使用内存之前，先申请分配一定数量的、大小相等(一般情况下)的内存块留作备用。当有新的内存需求时，就从内存池中分出一部分内存块，若内存块不够再继续申请新的内存。这样做的一个显著优点是尽量避免了内存碎片，使得内存分配效率得到提升。不仅在用户态应用程序中被广泛使用，同时在Linux内核也被广泛使用，在内核中有不少地方内存分配不允许失败。作为一个在这些情况下确保...
(内存池) 基于嵌入式指针的简单内存池
cuber-lotus的博客
08-22 953
内存池_百度百科 (baidu.com)(Memory Pool)是一种内存分配方式，又被称为固定大小区块规划（fixed-size-blocks allocation）。通常我们习惯直接使用new、malloc等API申请分配内存，这样做的缺点在于：由于所申请内存块的大小不定，当频繁使用时会造成大量的内存碎片并进而降低性能。内存池的实现方式多种多样，而本文仅实现一个简单的内存池，主要运用到嵌入式指针。嵌入式指针，指的在数据单元中，用一部分空间保存某一块空间的地址信息。实现方式多种多样。
嵌入式操作系统内核原理和开发（等值block内存池设计）
嵌入式-老费，一个分享专业嵌入式知识的blog
08-12 5172
【 声明：版权所有，欢迎转载，请勿用于商业用途。 联系信箱：feixiaoxing @163.com】 内存池设计是嵌入式系统的一个重要环节，之前我们也讨论过相关的内容。但是，看了rawos的代码之后，我觉得rawos的内存池设计更有特点。整个内存池的设计非常健壮，不但考虑了字节对齐的问题，而且还引入了等待调度机制，这是我所没有想到的。所以，在此我很愿意和大家分享这份优秀的代码。闲话
内存池中的嵌入式指针
weixin_43862733的博客
06-23 311
嵌入式指针 可以union改struct 内存分配后 next指针就没用了 直接作为数据空间比较省内存 因为对指针指向的内存存储的时候 编译器是不管你是什么类型的 ，这里有道练习题可以对指针的概念稍微理解一下： 由于嵌入式指针节省内存的特点 几乎所有的内存池都会使用 内存池一般不是为了提高效率而是为了减少cookie，设想一下节省100万个指针的存储会节省多少空间。...
嵌入式实时操作系统的设计与开发（内存资源池存储管理）
最新发布
Caramel_biscuit的博客
10-22 254
分配线程空间时提到：线程分配空间函数acoral_alloc_thread()通过调用acoral_get_res()为线程的资源控制块分配空间“return (acoral_thread_t *)acoral_get_res(&acoral_thread_pool_ctrl);每个资源池有一个ID，当资源池空闲时，ID的高16位表示该资源对象在资源池的编号，分配后表示该资源的ID，next_id为空闲链表指针，空闲时该16位指向下一个空闲的资源对象编号，分配完后，就没有意义了，属于资源ID的一部分。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值