[HarmonyOS] 深层剖析鸿蒙轻内核M核的动态内存如何支持多段非连续性内存

摘要：鸿蒙轻内核M核新增支持了多段非连续性内存区域，把多个非连续性内存逻辑上合一，用户不感知底层的不同内存块。

typedef struct {
  VOID *startAddress; /* 内存区域的开始地址 */
  UINT32 length;    /* 内存区域的长度 */
} LosMemRegion;

#if (LOSCFG_MEM_MUL_REGIONS == 1)
/** 
 *  When LOSCFG_MEM_MUL_REGIONS is enabled to support multiple non-continuous memory regions, the gap between two memory regions 
 *  is marked as a used OsMemNodeHead node. The gap node could not be freed, and would also be skipped in some DFX functions. The 
 *  'ptr.prev' pointer of this node is set to OS_MEM_GAP_NODE_MAGIC to identify that this is a gap node. 
*/
⑴  #define OS_MEM_GAP_NODE_MAGIC     0xDCBAABCD
⑵  #define OS_MEM_MARK_GAP_NODE(node)  (((struct OsMemNodeHead *)(node))->ptr.prev = (struct OsMemNodeHead *)OS_MEM_GAP_NODE_MAGIC)
⑶  #define OS_MEM_IS_GAP_NODE(node)  (((struct OsMemNodeHead *)(node))->ptr.prev == (struct OsMemNodeHead *)OS_MEM_GAP_NODE_MAGIC)
#else
⑵  #define OS_MEM_MARK_GAP_NODE(node)
⑶  #define OS_MEM_IS_GAP_NODE(node)  FALSE
#endif

  

• 1、把多段内存区域的第一块内存区域调用LOS_MemInit进行初始化  
  
• 2、获取下一个内存区域的开始地址和长度，计算该内存区域和上一块内存区域的间隔大小gapSize。  
  
• 3、把内存块间隔部分视为虚拟的已使用节点，使用上一内存块的尾节点，设置其大小为gapSize+ OS_MEM_NODE_HEAD_SIZE。  
  
• 4、把当前内存区域划分为一个空闲内存块和一个尾节点，把空闲内存块插入到空闲链表。并设置各个节点的前后链接关系。  
  
• 5、有更多的非连续内存块，重复上述步骤2-4。
  

  

• LOSCFG_MEM_MUL_REGIONS=0：
  

  

• LOSCFG_MEM_MUL_REGIONS=1：
  

  

• 
  
     
  
  • 如果pool为空，则合并到主内存堆m_aucSysMem0。   
    
  • 如果不为空，则初始化一个新的内存池，合并多内存区域为一个从堆。   
    
    
  

/**
 * @ingroup los_memory
 * @brief Initialize multiple non-continuous memory regions.
 *
 * @par Description:
 * <ul>
 * <li>This API is used to initialize multiple non-continuous memory regions. If the starting address of a pool is specified,
 *  the memory regions will be linked to the pool as free nodes. Otherwise, the first memory region will be initialized as a 
 *  new pool, and the rest regions will be linked as free nodes to the new pool.</li>
 * </ul>
 * 
 * @attention
 * <ul>
 * <li>If the starting address of a memory pool is specified, the start address of the non-continuous memory regions should be
 *  greater than the end address of the memory pool.</li>
 * <li>The multiple non-continuous memory regions shouldn't conflict with each other.</li>
 * </ul>
 *
 * @param pool       [IN] The memory pool address. If NULL is specified, the start address of first memory region will be 
 *              initialized as the memory pool address. If not NULL, it should be a valid address of a memory pool.
 * @param memRegions   [IN] The LosMemRegion array that contains multiple non-continuous memory regions. The start address
 *               of the memory regions are placed in ascending order.
 * @param memRegionCount [IN] The count of non-continuous memory regions, and it should be the length of the LosMemRegion array.
 * 
 * @retval #LOS_NOK  The multiple non-continuous memory regions fails to be initialized.
 * @retval #LOS_OK   The multiple non-continuous memory regions is initialized successfully.
 * @par Dependency:
 * <ul>
 * <li>los_memory.h: the header file that contains the API declaration.</li>
 * </ul>
 * @see None.
 */
extern UINT32 LOS_MemRegionsAdd(VOID *pool, const LosMemRegion * const memRegions, UINT32 memRegionCount);

#if (LOSCFG_MEM_MUL_REGIONS == 1)
STATIC INLINE UINT32 OsMemMulRegionsParamCheck(VOID *pool, const LosMemRegion * const memRegions, UINT32 memRegionCount)
{
  const LosMemRegion *memRegion = NULL;
  VOID *lastStartAddress = NULL;
  VOID *curStartAddress = NULL;
  UINT32 lastLength;
  UINT32 curLength;
  UINT32 regionCount;
  if ((pool != NULL) && (((struct OsMemPoolHead *)pool)->info.pool != pool)) {
    PRINT_ERR("wrong mem pool addr: %p, func: %s, line: %d\n", pool, __FUNCTION__, __LINE__);
    return LOS_NOK;
  }
  if (pool != NULL) {
    lastStartAddress = pool;
    lastLength = ((struct OsMemPoolHead *)pool)->info.totalSize;
  }
  memRegion = memRegions;
  regionCount = 0;
  while (regionCount < memRegionCount) {
    curStartAddress = memRegion->startAddress;
    curLength = memRegion->length;
    if ((curStartAddress == NULL) || (curLength == 0)) {
      PRINT_ERR("Memory address or length configured wrongly:address:0x%x, the length:0x%x\n", (UINTPTR)curStartAddress, curLength);
      return LOS_NOK;
    }
    if (((UINTPTR)curStartAddress & (OS_MEM_ALIGN_SIZE - 1)) || (curLength & (OS_MEM_ALIGN_SIZE - 1))) {
      PRINT_ERR("Memory address or length configured not aligned:address:0x%x, the length:0x%x, alignsize:%d\n", \
           (UINTPTR)curStartAddress, curLength, OS_MEM_ALIGN_SIZE);
      return LOS_NOK;
    }
    if ((lastStartAddress != NULL) && (((UINT8 *)lastStartAddress + lastLength) >= (UINT8 *)curStartAddress)) {
      PRINT_ERR("Memory regions overlapped, the last start address:0x%x, the length:0x%x, the current start address:0x%x\n", \
           (UINTPTR)lastStartAddress, lastLength, (UINTPTR)curStartAddress);
      return LOS_NOK;
    }
    memRegion++;
    regionCount++;
    lastStartAddress = curStartAddress;
    lastLength = curLength;
  }
  return LOS_OK;
}
STATIC INLINE VOID OsMemMulRegionsLink(struct OsMemPoolHead *poolHead, VOID *lastStartAddress, UINT32 lastLength, struct OsMemNodeHead *lastEndNode, const LosMemRegion *memRegion)
{
  UINT32 curLength;
  UINT32 gapSize;
  struct OsMemNodeHead *curEndNode = NULL;
  struct OsMemNodeHead *curFreeNode = NULL;
  VOID *curStartAddress = NULL;
  curStartAddress = memRegion->startAddress;
  curLength = memRegion->length;
  // mark the gap between two regions as one used node
  gapSize = (UINT8 *)(curStartAddress) - ((UINT8 *)(lastStartAddress) + lastLength);
  lastEndNode->sizeAndFlag = gapSize + OS_MEM_NODE_HEAD_SIZE;
  OS_MEM_SET_MAGIC(lastEndNode);
  OS_MEM_NODE_SET_USED_FLAG(lastEndNode->sizeAndFlag);
  // mark the gap node with magic number
  OS_MEM_MARK_GAP_NODE(lastEndNode);
  poolHead->info.totalSize += (curLength + gapSize);
  poolHead->info.totalGapSize += gapSize;
  curFreeNode = (struct OsMemNodeHead *)curStartAddress;
  curFreeNode->sizeAndFlag = curLength - OS_MEM_NODE_HEAD_SIZE;
  curFreeNode->ptr.prev = lastEndNode;
  OS_MEM_SET_MAGIC(curFreeNode);
  OsMemFreeNodeAdd(poolHead, (struct OsMemFreeNodeHead *)curFreeNode);
  curEndNode = OS_MEM_END_NODE(curStartAddress, curLength);
  curEndNode->sizeAndFlag = 0;
  curEndNode->ptr.prev = curFreeNode;
  OS_MEM_SET_MAGIC(curEndNode);
  OS_MEM_NODE_SET_USED_FLAG(curEndNode->sizeAndFlag);
#if (LOSCFG_MEM_WATERLINE == 1)
  poolHead->info.curUsedSize += OS_MEM_NODE_HEAD_SIZE;
  poolHead->info.waterLine = poolHead->info.curUsedSize;
#endif
}
UINT32 LOS_MemRegionsAdd(VOID *pool, const LosMemRegion *const memRegions, UINT32 memRegionCount)
{
  UINT32 ret;
  UINT32 lastLength;
  UINT32 curLength;
  UINT32 regionCount;
  struct OsMemPoolHead *poolHead = NULL;
  struct OsMemNodeHead *lastEndNode = NULL;
  struct OsMemNodeHead *firstFreeNode = NULL;
  const LosMemRegion *memRegion = NULL;
  VOID *lastStartAddress = NULL;
  VOID *curStartAddress = NULL;
  ret = OsMemMulRegionsParamCheck(pool, memRegions, memRegionCount);
  if (ret != LOS_OK) {
    return ret;
  }
  memRegion = memRegions;
  regionCount = 0;
  if (pool != NULL) { // add the memory regions to the specified memory pool
    poolHead = (struct OsMemPoolHead *)pool;
    lastStartAddress = pool;
    lastLength = poolHead->info.totalSize;
  } else { // initialize the memory pool with the first memory region
    lastStartAddress = memRegion->startAddress;
    lastLength = memRegion->length;
    poolHead = (struct OsMemPoolHead *)lastStartAddress;
    ret = LOS_MemInit(lastStartAddress, lastLength);
    if (ret != LOS_OK) {
      return ret;
    }
    memRegion++;
    regionCount++;
  }
  firstFreeNode = OS_MEM_FIRST_NODE(lastStartAddress);
  lastEndNode = OS_MEM_END_NODE(lastStartAddress, lastLength);
  while (regionCount < memRegionCount) { // traverse the rest memory regions, and initialize them as free nodes and link together
    curStartAddress = memRegion->startAddress;
    curLength = memRegion->length;
    OsMemMulRegionsLink(poolHead, lastStartAddress, lastLength, lastEndNode, memRegion);
    lastStartAddress = curStartAddress;
    lastLength = curLength;
    lastEndNode = OS_MEM_END_NODE(curStartAddress, curLength);
    memRegion++;
    regionCount++;
  }
  firstFreeNode->ptr.prev = lastEndNode;
  return ret;
}
#endif