MTK 内存管理简单总结

爱被打了一巴掌 2022-09-29 06:03 200阅读 0赞

MTK 手机用的操作系统是 nucleus, 这是一个rtfs(实时操作系统)，这个rtfs本身是不带内存管理功能，所以MTK自己写的内存管理。  
  
(nucleus在系统初始化完毕时，会调用Application\_Initialize，参数就是可使用内存的起始地址)  
  
大体上来分，MTK内存可以分为3种：  
  
control buffer  
平常使用的OslMalloc就是这个内存。  
  
这个内存内部实现是按块来划分的(pool)，具体的配置可以custom\_config.c 文件里的custom\_config\_ctrl\_buff\_info()里看到  
  
里面的size 指定了这个块的大小，no\_of\_buff 指定了有多少个这样的块。  
  
按块来管理内存，可以有效地控制内存的碎片，管理也相对简单，可能会造成内存的一些浪费  
  
对于手机这种需要长时间运行不重起的设备来说，还是很有必要的。  
  
MTK 默认最大块的大小为 2048byte，也就是2k。这就是说用OslMalloc 分配内存默认最大能分配到2k，  
  
这个可以看custom\_config\_ctrl\_buff\_info()配置可以看到。  
  
可以通过修改里面的配置来改变这个值，不过一般不这么做，因为MTK提供了其他的内存管理方式  
  
system buffer  
system buffer 平时我们用不到，听名字也是系统使用的。  
  
主要是提供 run-time usage,是一块 semi-static memory(什么意思？)  
  
比如 block of task, task stack ,control block of control buffer ,buffer pool等等  
  
在 custom\_config.c里面配置 ，主要有两个宏 GLOBAL\_MEM\_SIZE 和 GLOBAL\_DEBUG\_MEM\_SIZE  
两个 static 数组 static kal\_uint32 System\_Mem\_Pool\[GLOBAL\_MEM\_SIZE/sizeof(kal\_uint32)\];  
和 static kal\_uint32 Debug\_Mem\_Pool\[GLOBAL\_DEBUG\_MEM\_SIZE/sizeof(kal\_uint32)\];  
  
为了满足时间要求，也就是要求快速分配，系统内存又分为 internal system memory 和 system memory  
前者link 到 internal SRAM ,后者link 到 external SRAM  
  
app buffer  
app的内存是使用通过MTK 提供的一种ADM(application dynamic memory)机制来实现，ADM 主要的功能是通过管理一个数组来实现内存的分配。  
  
ADM 也是通过内存块(pool)来实现的，具体无法看到其代码。app通过这个adm这个机制，可以更加灵活的使用内存，比如分配大内存(大于2k)等等  
  
主要函数  
  
  
创建 adm  
KAL\_ADM\_ID kal\_adm\_create(void \*mem\_addr, kal\_uint32 size, kal\_uint32 \*subpool\_size, kal\_bool islogging);  
  
删除函数  
kal\_status kal\_adm\_delete(KAL\_ADM\_ID adm\_id);  
  
分配函数  
extern void \*kal\_adm\_internal\_alloc(KAL\_ADM\_ID adm\_id, kal\_uint32 size, char \*filename, kal\_uint32 line);  
\#define kal\_adm\_alloc(adm\_id, size) kal\_adm\_internal\_alloc(adm\_id, size, \_\_FILE\_\_, \_\_LINE\_\_)  
  
释放函数  
extern void kal\_adm\_free(KAL\_ADM\_ID adm\_id, void \*mem\_addr);  
  
在 MTK 内存管理简单总结 中，大体说了MTK的三种内存分配方式，对于第三种，也就是app buffer，是比较丰富的一种。  
  
在 MTK 平台中也有许多具体的实现。在代码里搜索一下 kal\_adm\_create 就可以发现有许多地方使用了。  
  
看一个比较典型的使用：  
  
在文件app\_mem.c里，有两个memory pool，一个是用于应用之间共享内存，另一个是用于屏幕内存。  
  
第一种内存，主要是用于各种应用之间共享内存(以下简称ASM)，这样可以节省内存，MTK实现了一种机制，可以在多个应用之间共享内存  
  
当当前应用想获得的共享内存不足时，MTK会通知后台应用释放相应的内存。这套机制在AppMemMgr.c里面实现。  
  
先看一下初始化该内存次池函数  
  
void applib\_mem\_ap\_init(void (\*stop\_finish\_callback\_by\_MMI)(kal\_uint32 app\_id, kal\_uint32 string\_id, kal\_bool result))  
  
这个函数带有一个参数，这个参数是一个函数指针，该回调函数有3个参数，app\_id,(应用id),string\_id 和 result。  
  
这个回调函数比较特别，是当一个后台应用 被 要求释放内存，释放完毕后调用的。  
  
为什么要搞这么一个函数，因为一些应用比较复杂，释放内存的同时需要关闭一些资源，而这些动作是异步的，  
  
等这些异步发的操作多完成时，调用一些函数，告诉ASM，内存释放完毕。  
  
具体实现：通过 调用 kal\_adm\_create 来创建一个内存池，然后保存了一些回调函数，没有什么特别的地方，  
  
内存池的大小 是 APPLIB\_MEM\_AP\_POOL\_SIZE 来确定的，可以通过修改 app\_asm\_pool\_union 来修改内存池的大小。  
  
应用分配内存  
  
void \*applib\_mem\_ap\_alloc(kal\_uint32 app\_id, kal\_uint32 mem\_size)  
  
应用通过上面的函数来获得ASM的内存，参数一 app\_id，是当前分配内存的id，这个id需要自己定义，并且注册(下文说明)，  
  
参数二是实际需要分配的内存大小。  
  
具体实现：先mem\_size 进行了处理，让其四字节对齐。然后通过 kal\_adm\_alloc 获得内存，不过这个内存加上了一个头结构和尾结构，  
  
(头和尾都加入了特殊字符，再释放时进行检查，这个可以判断内存是否越界)。然后把这个内存插入到list的头部。  
  
昨天说到了内存的分配。下面看一下内存释放  
  
主要进行了3步：  
  
static void applib\_mem\_ap\_free\_int(void \*mem\_ptr)  
\{  
/\*----------------------------------------------------------------\*/  
/\* Local Variables \*/  
/\*----------------------------------------------------------------\*/  
applib\_mem\_header\_struct \*header, \*prev\_node, \*remove\_node;  
applib\_mem\_footer\_struct \*footer;  
  
/\*----------------------------------------------------------------\*/  
/\* Code Body \*/  
/\*----------------------------------------------------------------\*/  
if (g\_applib\_mem\_cntx.app\_pool\_id) /\* Normal mode \*/  
\{  
ASSERT(mem\_ptr && APPLIB\_MEM\_ALIGNED\_4(mem\_ptr));  
  
header = ((applib\_mem\_header\_struct\*) mem\_ptr) - 1;  
footer = (applib\_mem\_footer\_struct\*) (((char\*)mem\_ptr) + header->chunk\_size);  
  
ASSERT(APPLIB\_MEM\_COMP\_PATTERN(header->guard\_pattern, APPLIB\_MEM\_HEADER\_PATTERN1) &&  
APPLIB\_MEM\_COMP\_PATTERN(footer->guard\_pattern, APPLIB\_MEM\_FOOTER\_PATTERN1));  
  
/\*  
\* Remove the block from linked list  
\*  
\* It is not a fast algorithm, we can improve it by using double linked list,  
\* but we choose simpler design because  
\* 1. Typically total allocation count is small  
\* 2. We don't want to increase space overheads  
\* 3. We don't want to access KAL ADM internal data structure  
\*/  
prev\_node = &g\_applib\_mem\_cntx.app\_head;  
ASSERT(prev\_node->next);  
for (remove\_node = prev\_node->next;  
remove\_node;  
prev\_node = remove\_node, remove\_node = prev\_node->next)  
\{  
if (remove\_node == header)  
\{  
break;  
\}  
\}  
ASSERT(remove\_node);  
prev\_node->next = remove\_node->next;  
  
/\* Set guard pattern \*/  
APPLIB\_MEM\_SET\_PATTERN(header->guard\_pattern, APPLIB\_MEM\_HEADER\_PATTERN2);  
APPLIB\_MEM\_SET\_PATTERN(footer->guard\_pattern, APPLIB\_MEM\_FOOTER\_PATTERN2);  
  
/\* Release the block \*/  
\#ifdef APPLIB\_MEM\_USE\_ADM  
kal\_adm\_free(g\_applib\_mem\_cntx.app\_pool\_id, header);  
\#else  
free(header);  
\#endif  
  
ASSERT(g\_applib\_mem\_cntx.app\_alloc\_count > 0);  
g\_applib\_mem\_cntx.app\_alloc\_count--;  
\}  
else /\* Full pool mode \*/  
\{  
ASSERT(mem\_ptr == g\_applib\_mem\_ap\_pool && g\_applib\_mem\_cntx.app\_alloc\_count == 1);  
g\_applib\_mem\_cntx.app\_alloc\_count = 0;  
g\_applib\_mem\_cntx.app\_id\_of\_full\_pool = APPLIB\_MEM\_AP\_ID\_DUMMY; /\* 0 \*/  
  
\#ifdef APPLIB\_MEM\_USE\_ADM  
g\_applib\_mem\_cntx.app\_pool\_id = kal\_adm\_create(  
g\_applib\_mem\_ap\_pool,  
APPLIB\_MEM\_AP\_POOL\_SIZE,  
(kal\_uint32\*) g\_applib\_mem\_pool\_chunk\_size,  
KAL\_FALSE);  
\#else /\* APPLIB\_MEM\_USE\_ADM \*/  
g\_applib\_mem\_cntx.app\_pool\_id = APPLIB\_DUMMY\_POOL\_ID;  
\#endif /\* APPLIB\_MEM\_USE\_ADM \*/  
\}  
\}  
  
取得内存的头部和尾部，(调试版本可以判断内存是否越界)  
从链表中删除这个节点  
调用 kal\_adm\_free 释放内存  
在MTK 内存管理简单总结 2 提到调用 applib\_mem\_ap\_alloc 分配内存是需要一个应用id，这个id是需要自己增加，  
  
而且在调用这个函数之前必须 调用 applib\_mem\_ap\_register 注册这个id。需要注意的是最后一个参数，是一个回调函数，  
  
这个回调函数是在共享内存不够使用时，ASM会调用这个函数，告诉应用需要释放共享内存，供其它应用使用。  
  
增加 id 在 app\_mem.h 的 applib\_mem\_ap\_id\_enum 里面，只要添加一个id就可以。  
  
同样 屏幕内存也是通过ADM来管理，屏幕内存 是用来 创建 layer 用的，在MTK的某个版本开始，创建layer的内存是有要求的，  
  
需要applib\_mem\_screen\_alloc 分配的内存。  
  
本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/yanwuxufeng/archive/2010/07/14/5735911.aspx