SylixOS中的动态内存分配 --- 内核堆与系统堆

概念

内核堆（kernel heap）与系统堆（system heap）是SylixOS原生的内存堆模块，用于内核和驱动的动态内存分配。大多数情况下系统堆是等同于内核堆的。

内核堆与系统堆通过内存堆操作库实现，以宏函数为接口。

接口

内核堆接口

#define __KHEAP_ALLOC(stNBytes)                 _HeapAllocate(_K_pheapKernel, stNBytes, __func__)
#define __KHEAP_ZALLOC(stNBytes)                _HeapZallocate(_K_pheapKernel, stNBytes, __func__)
#define __KHEAP_REALLOC(pvMemory, stNBytes)     _HeapRealloc(_K_pheapKernel, pvMemory, stNBytes, LW_FALSE, __func__)       
#define __KHEAP_ALLOC_ALIGN(stNBytes, stAlgin)  _HeapAllocateAlign(_K_pheapKernel, stNBytes, stAlgin, __func__)        
#define __KHEAP_FREE(pvMemory)                  _HeapFree(_K_pheapKernel, pvMemory, LW_FALSE, __func__)

#define ker_malloc(size)                		__KHEAP_ALLOC((size_t)(size))
#define ker_zalloc(size)                		__KHEAP_ZALLOC((size_t)(size))
#define ker_free(p)                     		__KHEAP_FREE((p))
#define ker_realloc(p, new_size)        		__KHEAP_REALLOC((p), (size_t)(new_size))
#define ker_malloc_align(size, align)   		__KHEAP_ALLOC_ALIGN((size_t)(size), (size_t)(align))

系统堆接口

#define __SHEAP_ALLOC(stNBytes)                 _HeapAllocate(_K_pheapSystem, stNBytes, __func__)
#define __SHEAP_ZALLOC(stNBytes)                _HeapZallocate(_K_pheapSystem, stNBytes, __func__)
#define __SHEAP_REALLOC(pvMemory, stNBytes)     _HeapRealloc(_K_pheapSystem, pvMemory, stNBytes, LW_FALSE, __func__)
#define __SHEAP_ALLOC_ALIGN(stNBytes, stAlgin)  _HeapAllocateAlign(_K_pheapSystem, stNBytes, stAlgin, __func__)
#define __SHEAP_FREE(pvMemory)                  _HeapFree(_K_pheapSystem, pvMemory, LW_FALSE, __func__)

#define sys_malloc(size)                		__SHEAP_ALLOC((size_t)(size))
#define sys_zalloc(size)                		__SHEAP_ZALLOC((size_t)(size))
#define sys_free(p)                     		__SHEAP_FREE((p))
#define sys_realloc(p, new_size)        		__SHEAP_REALLOC((p), (size_t)(new_size))
#define sys_malloc_align(size, align)   		__SHEAP_ALLOC_ALIGN((size_t)(size), (size_t)(align))

Linux兼容的内核动态分配接口

#define kzalloc(size, flags)					sys_zalloc(size)
#define vmalloc(size)		    				sys_malloc(size)
#define kfree(ptr)		        				sys_free((void *)ptr)
#define vfree(ptr)		        				sys_free(ptr)

用法

• __KHEAP_ALLOC
• __KHEAP_FREE

/*********************************************************************************************************
** 函数名称: _JobQueueCreate
** 功能描述: 创建一个工作队列
** 输　入  : uiQueueSize       队列大小
**           bNonBlock         执行函数是否为非阻塞方式
** 输　出  : 工作队列控制块 
*********************************************************************************************************/
PLW_JOB_QUEUE  _jobQueueCreate (UINT uiQueueSize, BOOL bNonBlock)
{
    PLW_JOB_QUEUE pjobq;
    
    pjobq = (PLW_JOB_QUEUE)__KHEAP_ALLOC((size_t)(sizeof(LW_JOB_QUEUE) + 
                                         (uiQueueSize * sizeof(LW_JOB_MSG))));
    if (pjobq == LW_NULL) {
        _DebugHandle(__ERRORMESSAGE_LEVEL, "kernel low memory.\r\n");
        _ErrorHandle(ERROR_KERNEL_LOW_MEMORY);
        return  (LW_NULL);
    }
    
    pjobq->JOBQ_pjobmsgQueue = (PLW_JOB_MSG)(pjobq + 1);
    pjobq->JOBQ_uiIn         = 0;
    pjobq->JOBQ_uiOut        = 0;
    pjobq->JOBQ_uiCnt        = 0;
    pjobq->JOBQ_uiSize       = uiQueueSize;
    pjobq->JOBQ_ulLost       = 0;
    
    if (bNonBlock == LW_FALSE) {
        pjobq->JOBQ_ulSync = API_SemaphoreBCreate("job_sync", LW_FALSE, LW_OPTION_OBJECT_GLOBAL, LW_NULL);
        if (pjobq->JOBQ_ulSync == LW_OBJECT_HANDLE_INVALID) {
            __KHEAP_FREE(pjobq);
            return  (LW_NULL);
        }
    } else {
        pjobq->JOBQ_ulSync = LW_OBJECT_HANDLE_INVALID;
    }
    
    LW_SPIN_INIT(&pjobq->JOBQ_slLock);
    
    return  (pjobq);
}

• __KHEAP_ALLOC_ALIGN

/*********************************************************************************************************
** 函数名称: API_CacheDmaMalloc
** 功能描述: 开辟一块非缓冲的内存
** 输　入  : 
**           stBytes                       长度
** 输　出  : 开辟的空间首地址
*********************************************************************************************************/ 
PVOID    API_CacheDmaMalloc (size_t   stBytes)
{
    return  ((_G_cacheopLib.CACHEOP_pfuncDmaMalloc == LW_NULL) ?
             (__KHEAP_ALLOC_ALIGN(stBytes, LW_CFG_CPU_ARCH_CACHE_LINE)) :
             (_G_cacheopLib.CACHEOP_pfuncDmaMalloc(stBytes)));
}

• __SHEAP_ALLOC
• __SHEAP_FREE

/*********************************************************************************************************
** 函数名称: _rngCreate
** 功能描述: 建立一个 VxWorks 兼容 ring buffer 缓冲区
** 输　入  : 缓冲区大小
** 输　出  : 缓冲区控制块地址 
*********************************************************************************************************/
VX_RING_ID  _rngCreate (INT  iNBytes)
{
    REGISTER PCHAR        pcBuffer;
    REGISTER VX_RING_ID   vxringid;
             size_t       stAllocSize;
    
    /* 
     *  bump number of bytes requested because ring buffer algorithm
     *  always leaves at least one empty byte in buffer 
     */
    iNBytes++;
    stAllocSize = (size_t)(sizeof(VX_RING) + iNBytes);
    
    /*
     *  统一分配内存避免内存碎片
     */
    vxringid = (VX_RING_ID)__SHEAP_ALLOC(stAllocSize);
    if (vxringid == LW_NULL) {
        return  (LW_NULL);
    }
    pcBuffer = (PCHAR)vxringid + sizeof(VX_RING);
    
    vxringid->VXRING_iBufByteSize = iNBytes;
    vxringid->VXRING_pcBuf        = pcBuffer;
    
    _rngFlush(vxringid);
    
    return  (vxringid);
}
/*********************************************************************************************************
** 函数名称: _rngDelete
** 功能描述: 删除一个 VxWorks 兼容 ring buffer 缓冲区
** 输　入  : 缓冲区控制块地址
** 输　出  : 
*********************************************************************************************************/
VOID  _rngDelete (VX_RING_ID  vxringid)
{
    __SHEAP_FREE(vxringid);
}