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

快来打我* 2022-08-28 01:57 225阅读 0赞

# 概念 #

内核堆（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);
    }