[文章]

鸿蒙内核源码分析(内存分配篇):内存的分配方式有哪些

2020-11-20 10:07:27  532 鸿蒙系统 内核 源码
分享
0
鸿蒙内核有多少代码
内存部分占了整个kernel代码量近30%,代码多实现复杂,而且内存部分还分了两个文件夹mem,vm大书特书,为什么要分两个文件夹?应该是鸿蒙内核开发者想从目录的名称上区分内存的层级概念,vm是内存模块的更底层实现,mem是提供给上层使用对vm层的调用。

mem层
mem层介绍可以参考 LiteOS > 开发指南> 内核开发指南> 内存> 概述 看,有更详细的描述,这里结合代码说。
Huawei LiteOS的内存管理分为静态内存管理和动态内存管理,提供内存初始化、分配、释放等功能。

动态内存:在动态内存池中分配用户指定大小的内存块。
  • 优点:按需分配。
  • 缺点:内存池中可能出现碎片。

静态内存:在静态内存池中分配用户初始化时预设(固定)大小的内存块。
  • 优点:分配和释放效率高,静态内存池中无碎片。
  • 缺点:只能申请到初始化预设大小的内存块,不能按需申请。
动态内存管理,即在内存资源充足的情况下,从系统配置的一块比较大的连续内存(内存池),根据用户需求,分配任意大小的内存块。当用户不需要该内存块时,又可以释放回系统供下一次使用。与静态内存相比,动态内存管理的好处是按需分配,缺点是内存池中容易出现碎片。LiteOS动态内存支持DLINK和BEST LITTLE两种标准算法。

动态内存接口函数
动态内存管理模块为用户提供下面几种功能。
功能分类
接口名
描述
内存初始化
LOS_MemInit
初始化一块指定的动态内存池,大小为size。
申请动态内存
LOS_MemAlloc
从指定动态内存池中申请size长度的内存。
释放动态内存
LOS_MemFree
释放已申请的内存。
重新申请内存
LOS_MemRealloc
按size大小重新分配内存块,并保留原内存块内容。
内存对齐分配
LOS_MemAllocAlign
从指定动态内存池中申请长度为size且地址按boundary字节对齐的内存。
分析内存池状态
LOS_MemStatisticsGet
获取指定内存池的统计信息。
查看内存池中最大可用空闲块
LOS_MemGetMaxFreeBlkSize
获取指定内存池的最大可用空闲块。

这里LOS_MemAlloc被调用的情况,太长还有很多没截出来。
OsMemAllocWithCheck
采用内存池是嵌入式内存管理的一种常用做法,目的是减少申请和释放内存的开销,简单说就是先申请一大块内存,需要时从空闲链表中split,怎么切割鸿蒙就看最佳适应算法(best fit),用完了回收,node进入空闲链表,并从小到大排序,如果相邻两块都是可用内存块就合并。直接看LOS_MemAlloc内主要函数OsMemAllocWithCheck代码
  1. STATIC INLINE VOID *OsMemAllocWithCheck(VOID *pool, UINT32 size, UINT32 intSave)
  2. {
  3.     LosMemDynNode *allocNode = NULL;
  4.     UINT32 allocSize;
  5.     LosMemPoolInfo *poolInfo = (LosMemPoolInfo *)pool;
  6.     const VOID *firstNode = (const VOID *)((UINT8 *)OS_MEM_HEAD_ADDR(pool) + OS_DLNK_HEAD_SIZE);
  7.     INT32 ret;

  8.     if (OsMemAllocCheck(pool, intSave) == LOS_NOK) {
  9.         return NULL;
  10.     }

  11.     allocSize = OS_MEM_ALIGN(size + OS_MEM_NODE_HEAD_SIZE, OS_MEM_ALIGN_SIZE);
  12.     if (allocSize == 0) {
  13.         return NULL;
  14.     }
  15. retry:

  16.     allocNode = OsMemFindSuitableFreeBlock(pool, allocSize);//从内存池中找到合适的内存块
  17.     if (allocNode == NULL) {
  18.         if (poolInfo->flag & MEM_POOL_EXPAND_ENABLE) {
  19.             ret = OsMemPoolExpand(pool, allocSize, intSave);//木有找到就扩展内存池
  20.             if (ret == 0) {
  21.                 goto retry;
  22.             }
  23.         }
  24.         return NULL;
  25.     }
  26.     if ((allocSize + OS_MEM_NODE_HEAD_SIZE + OS_MEM_ALIGN_SIZE) <= allocNode->selfNode.sizeAndFlag) {
  27.         OsMemSplitNode(pool, allocNode, allocSize);//找到了就劈开node
  28.     }
  29.     OsMemListDelete(&allocNode->selfNode.freeNodeInfo, firstNode);//从空闲双链表中删除该节点
  30.     return (allocNode + 1);
  31. }
复制代码
很显然,最佳适应算法(best fit)去带来很多极小块内存碎片的问题。

vm层
vm目录:是虚拟内存的代码实现,包括物理内存的段页式管理,内存虚拟地址<->物理地址映射,缺页中断处理,分配大块内存的伙伴算法,LRU置换算法,以及针对用户态开发,提供的一套内存系统调用接口等等,这部分官方没有提供任何文档,代码注释也很少,全靠硬摸。

先说三种虚拟空间
空间(space)这个概念很重要,还记得进程描述符(LosProcessCB)里的LosVmSpace  *vmSpace吗?它是进程使用内存的方式,空间就是边界,进程只能在划定的空间里运行,任何指令都不能越界运行。

在鸿蒙内核源码分析(内存分配篇)中已讲明虚拟内存是MMU带出来的概念,为解决物理内存满足不了多进程对内存的需要。虚拟内存可以远大于物理内存。虚拟空间是进程层面的概念,每个进程都有一个,给进程独享整个物理内存的假象。对鸿蒙来说操作系统和驱动程序运行在内核空间(kernel space),应用程序运行在用户空间(user space), 在运行期间需动态分配的向堆空间(heap space)申请内存。具体看代码会更清晰些。
从空间的初始化调用关系上可以看出只有这三种空间,所不同的是 内核虚拟空间,堆虚拟空间只有一个,而每一个用户进程都有属于自己的用户虚拟空间。看看他们初始化代码:
  1. [size=4][color=#008000]//内核虚拟空间初始化
  2. BOOL OsKernVmSpaceInit(LosVmSpace *vmSpace, VADDR_T *virtTtb)
  3. {
  4.     vmSpace->base = KERNEL_ASPACE_BASE;
  5.     vmSpace->size = KERNEL_ASPACE_SIZE;
  6.     vmSpace->mapBase = KERNEL_VMM_BASE;
  7.     vmSpace->mapSize = KERNEL_VMM_SIZE;
  8. #ifdef LOSCFG_DRIVERS_TZDRIVER
  9.     vmSpace->codeStart = 0;
  10.     vmSpace->codeEnd = 0;
  11. #endif
  12.     return OsVmSpaceInitCommon(vmSpace, virtTtb);
  13. }
  14. //动态分配空间初始化
  15. BOOL OsVMallocSpaceInit(LosVmSpace *vmSpace, VADDR_T *virtTtb)
  16. {
  17.     vmSpace->base = VMALLOC_START;
  18.     vmSpace->size = VMALLOC_SIZE;
  19.     vmSpace->mapBase = VMALLOC_START;
  20.     vmSpace->mapSize = VMALLOC_SIZE;
  21. #ifdef LOSCFG_DRIVERS_TZDRIVER
  22.     vmSpace->codeStart = 0;
  23.     vmSpace->codeEnd = 0;
  24. #endif
  25.     return OsVmSpaceInitCommon(vmSpace, virtTtb);
  26. }
  27. //用户虚拟空间初始化
  28. BOOL OsUserVmSpaceInit(LosVmSpace *vmSpace, VADDR_T *virtTtb)
  29. {
  30.     vmSpace->base = USER_ASPACE_BASE;
  31.     vmSpace->size = USER_ASPACE_SIZE;
  32.     vmSpace->mapBase = USER_MAP_BASE;
  33.     vmSpace->mapSize = USER_MAP_SIZE;
  34.     vmSpace->heapBase = USER_HEAP_BASE;
  35.     vmSpace->heapNow = USER_HEAP_BASE;
  36.     vmSpace->heap = NULL;
  37. #ifdef LOSCFG_DRIVERS_TZDRIVER
  38.     vmSpace->codeStart = 0;
  39.     vmSpace->codeEnd = 0;
  40. #endif
  41.     return OsVmSpaceInitCommon(vmSpace, virtTtb);
  42. }[/color][/size]
复制代码

它们唯一的区别是虚拟地址的开始位置和大小不一样,但是所有用户进程的虚拟地址都是一样的,注意用户进程是一样的,细品。
  1. [size=4][color=#008000]STATIC BOOL OsVmSpaceInitCommon(LosVmSpace *vmSpace, VADDR_T *virtTtb)
  2. {
  3.     LOS_RbInitTree(&vmSpace->regionRbTree, OsRegionRbCmpKeyFn, OsRegionRbFreeFn, OsRegionRbGetKeyFn);//初始化虚拟存储区域-以红黑树组织方式

  4.     LOS_ListInit(&vmSpace->regions);//初始化虚拟存储区域-以双循环链表组织方式
  5.     status_t retval = LOS_MuxInit(&vmSpace->regionMux, NULL);//初始化互斥量
  6.     if (retval != LOS_OK) {
  7.         VM_ERR("Create mutex for vm space faiLED, status: %d", retval);
  8.         return FALSE;
  9.     }

  10.     (VOID)LOS_MuxAcquire(&g_vmSpaceListMux);
  11.     LOS_ListAdd(&g_vmSpaceList, &vmSpace->node);//加入到虚拟空间双循环链表
  12.     (VOID)LOS_MuxRelease(&g_vmSpaceListMux);

  13.     return OsArchMmuInit(&vmSpace->archMmu, virtTtb);//对空间mmu初始化
  14. }

  15. //通过虚拟地址获取所属空间地址
  16. LosVmSpace *LOS_SpaceGet(VADDR_T vaddr)
  17. {
  18.     if (LOS_IsKernelAddress(vaddr)) {
  19.         return LOS_GetKVmSpace();
  20.     } else if (LOS_IsUserAddress(vaddr)) {
  21.         return OsCurrProcessGet()->vmSpace;//当前进程的虚拟空间
  22.     } else if (LOS_IsVmallocAddress(vaddr)) {
  23.         return LOS_GetVmallocSpace();
  24.     } else {
  25.         return NULL;
  26.     }
  27. }[/color][/size]
复制代码

这些空间都挂在 g_vmSpaceList 双循环链表上,LOS_SpaceGet可以通过虚拟地址反查是属于哪种空间。每一个空间都有一张页表和物理内存页表形成映射关系,虚拟内存和物理内存都是页对页的映射,两边每页都是4K,也必须是一样的!否则无法完成映射。具体如何映射的将在鸿蒙内核源码分析(内存映射篇)中说明,在调度算法切换进程时就需要切换至该进程自己的虚拟空间,即MMU上下文。
物理内存初始化
物理内存部分见代码: los_vm_phys.c,到了物理内存就没有什么进程,空间的概念了,只有页的概念!一页4K
物理内存的管理和分配都是围绕着页展开的,鸿蒙对物理内存使用了段页式管理,看代码吧,关键处都加了注释。
  1. [size=4][color=#008000]/* Physical memory area array */
  2. STATIC struct VmPhysArea g_physArea[] = {
  3.     {
  4.         .start = SYS_MEM_BASE, //整个物理内存基地址
  5.         .size = SYS_MEM_SIZE_DEFAULT,//整个物理内存总大小
  6.     },
  7. };
  8. //* page初始化
  9. VOID OsVmPageStartup(VOID)
  10. {
  11.     struct VmPhysSeg *seg = NULL;
  12.     LosVmPage *page = NULL;
  13.     paddr_t pa;
  14.     UINT32 nPage;
  15.     INT32 segID;

  16.     OsVmPhysAreaSizeAdjust(ROUNDUP((g_vmBootMemBase - KERNEL_ASPACE_BASE), PAGE_SIZE));//校正 g_physArea size

  17.     nPage = OsVmPhysPageNumGet();//得到 g_physArea 总页数
  18.     g_vmPageArraySize = nPage * sizeof(LosVmPage);//页表总大小
  19.     g_vmPageArray = (LosVmPage *)OsVmBootMemAlloc(g_vmPageArraySize);//申请页表存放区域

  20.     OsVmPhysAreaSizeAdjust(ROUNDUP(g_vmPageArraySize, PAGE_SIZE));// g_physArea 变小

  21.     OsVmPhysSegAdd();// 段页绑定
  22.     OsVmPhysInit();// 加入空闲链表和设置置换算法,LRU(最近最久未使用)算法

  23.     for (segID = 0; segID < g_vmPhysSegNum; segID++) {
  24.         seg = &g_vmPhysSeg[segID];
  25.         nPage = seg->size >> PAGE_SHIFT;
  26.         for (page = seg->pageBase, pa = seg->start; page <= seg->pageBase + nPage;
  27.              page++, pa += PAGE_SIZE) {
  28.             OsVmPageInit(page, pa, segID);//page初始化
  29.         }
  30.         OsVmPageOrderListInit(seg->pageBase, nPage);// 页面分配的排序
  31.     }
  32. }
  33. UINT32 OsVmPhysPageNumGet(VOID)
  34. {
  35.     UINT32 nPages = 0;
  36.     INT32 i;

  37.     for (i = 0; i < (sizeof(g_physArea) / sizeof(g_physArea[0])); i++) {
  38.         nPages += g_physArea[i].size >> PAGE_SHIFT;//右移12位,相当于除以4K,得出总页数
  39.     }

  40.     return nPages;
  41. }
  42. VOID OsVmPhysSegAdd(VOID)
  43. {
  44.     INT32 i, ret;

  45.     LOS_ASSERT(g_vmPhysSegNum <= VM_PHYS_SEG_MAX);
  46.         
  47.     for (i = 0; i < (sizeof(g_physArea) / sizeof(g_physArea[0])); i++) {
  48.         ret = OsVmPhysSegCreate(g_physArea[i].start, g_physArea[i].size);//一个区对应一个段
  49.         if (ret != 0) {
  50.             VM_ERR("create phys seg failed");
  51.         }
  52.     }
  53. }

  54. STATIC VOID OsVmPageInit(LosVmPage *page, paddr_t pa, UINT8 segID)
  55. {
  56.     LOS_ListInit(&page->node);//初始化链表节点
  57.     page->flags = FILE_PAGE_FREE;//默认空闲
  58.     LOS_AtomicSet(&page->refCounts, 0);//0次引用
  59.     page->physAddr = pa;//物理地址
  60.     page->segID = segID;//所属段
  61.     page->order = VM_LIST_ORDER_MAX;//伙伴算法默认级数
  62. }
  63. [/color][/size]
复制代码

代码中可以看出初始化对物理内存做了几个动作:
1.对整个物理内存进行了分页,每页框4K,存放在大页表数组中 g_vmPageArray
2.段页绑定,根据g_physArea数组的大小来创建段,因数组里只有一条数据,所以只有一个段
3.初始化了回收双链表和置换算法,采用了LRU置换算法。
4.对每一页框进行了初始化,每个页框可用于分配,指定了物理地址,注意这是物理内存的页。
5.对伙伴算法初始化。
什么是伙伴算法?
简单的说就是把所有的空闲页面分为10个块组,每组中块的大小是2的幂次方个页面,例如,第0组中块的大小都为2的0次方 (1个页面),第1组中块的大小为都为2的1次方(2个页面),第9组中块的大小都为2的9次方(512个页面)。也就是说,每一组中块的大小是相同的,且这同样大小的块形成一个链表,能看懂下面这张图的就看懂了伙伴算法,一个方块代表一个物理页框。
物理内存是怎么被分配的?
物理内存是以页为单位被分配的,详细看 LOS_PhysPagesAllocContiguous,看下哪些地方调用了它。
1.初始化进程块会用到  2.扩展内存池会用到,3,用户进程空间初始化会用到 4,内核动态分配的时候会到,这个上面已经讲过了。5.动态加载可执行程序会用到,LOS_PhysPagesAllocContiguous 调用的主要函数是:
  1. LosVmPage *OsVmPhysPagesAlloc(struct VmPhysSeg *seg, size_t nPages)
  2. {
  3.     struct VmFreeList *list = NULL;
  4.     LosVmPage *page = NULL;
  5.     UINT32 order;
  6.     UINT32 newOrder;

  7.     if ((seg == NULL) || (nPages == 0)) {
  8.         return NULL;
  9.     }

  10.     order = OsVmPagesToOrder(nPages);//根据页数计算出用哪个块组
  11.     if (order < VM_LIST_ORDER_MAX) {
  12.         for (newOrder = order; newOrder < VM_LIST_ORDER_MAX; newOrder++) {//没有就找更大块
  13.             list = &seg->freeList[newOrder];//从最合适的块处开始找
  14.             if (LOS_ListEmpty(&list->node)) {//没找到
  15.                 continue;//继续找更大块的
  16.             }
  17.             page = LOS_DL_LIST_ENTRY(LOS_DL_LIST_FIRST(&list->node), LosVmPage, node);//找到
  18.             goto DONE;
  19.         }
  20.     }
  21.     return NULL;
  22. DONE:
  23.     OsVmPhysFreeListDelUnsafe(page);
  24.     OsVmPhysPagesSpiltUnsafe(page, order, newOrder);
  25.     return page;
  26. }
复制代码
总结下:看到这里大家脑子里应该浮现出一幅图,内核抽象出无数个虚拟空间页表,但实际只有一个物理内存页表,每个虚拟空间都要映射到了物理内存页表上,他们是 1:N的关系,如何保证不会错呢?缺页了怎么处理?如何置换页面?怎么才能保证效率?请查看鸿蒙内核源码分析:虚拟地址与物理地址之间是如何映射的》


本文来源:图解鸿蒙源码逐行注释分析


评论

您需要登录后才可以回帖 登录 | 注册

声明:本文内容及配图由入驻作者撰写或者入驻合作网站授权转载。文章观点仅代表作者本人,不代表电子发烧友网立场。文章及其配图仅供工程师学习之用,如有内容图片侵权或者其他问题,请联系本站作侵删。 侵权投诉
发文章