SylixOS 内核工作队列

最新推荐文章于 2024-08-12 23:26:10 发布
最新推荐文章于 2024-08-12 23:26:10 发布
阅读量463 收藏 4
点赞数 1
分类专栏： SylixOS内核详解 # 工作队列 文章标签： SylixOS 工作队列 内核异步工作队列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ScilogyHunter/article/details/108586602
版权

1、概述

内核工作队列（JobQueue）位于内核文件libsylixos/SylixOS/kernel/core/_JobQueue.c中，是纯粹的针对工作队列对象的一些操作集合，供内核使用，系统工作队列和网络工作队列都是基于内核工作队列实现的。

内核工作队列本质上是基于数组型环形缓冲区实现的，同时使用了自旋锁进行过程保护和使用了信号量进行资源同步。实现过程比较简单，可以看源码直接分析。

2、相关数据结构

SylixOS内核中定义了两个用于管理工作队列的数据结构。

2.1、工作队列管理的消息

typedef struct {
    VOIDFUNCPTR         	JOBM_pfuncFunc;
    PVOID                 	JOBM_pvArg[LW_JOB_ARGS];
} LW_JOB_MSG;
  • JOBM_pfuncFunc：工作消息的回调函数；
  • JOBM_pvArg[LW_JOB_ARGS]：工作消息的回调函数的参数。

2.2、工作队列控制块

typedef struct {
    PLW_JOB_MSG          	JOBQ_pjobmsgQueue;
    UINT                  	JOBQ_uiIn;
    UINT                  	JOBQ_uiOut;
    UINT                  	JOBQ_uiCnt;
    UINT                  	JOBQ_uiSize;
    size_t                	JOBQ_stLost;
    LW_OBJECT_HANDLE    	JOBQ_ulSync;
    LW_SPINLOCK_DEFINE  	(JOBQ_slLock);
} LW_JOB_QUEUE;
  • JOBQ_pjobmsgQueue：工作队列消息；
  • JOBQ_uiIn：加入工作队列的消息数量；
  • JOBQ_uiOut：移出工作队列的消息数量；
  • JOBQ_uiCnt：当前工作队列中的消息数量；
  • JOBQ_uiSize：工作队列总大小；
  • JOBQ_stLost：工作队列丢失消息数量；
  • JOBQ_ulSync：工作队列同步等待信号；
  • JOBQ_slLock：锁定工作队列自旋锁。

3、相关接口函数

3.1 创建及删除工作队列

SylixOS中创建工作队列就是分配工作队列资源和初始化工作队列控制块中各成员的过程，与之对应，删除队列就是释放工作队列资源的过程。内核中提供了两种工作队列的创建和删除操作函数：动态/静态创建和删除工作队列。

 _JobQueueCreate
	原型 : PLW_JOB_QUEUE  _jobQueueCreate (UINT uiQueueSize, BOOL bNonBlock)
	输入 : uiQueueSize       队列大小
	       bNonBlock         执行函数是否为非阻塞方式
	返回 : 工作队列控制块
	说明 : 创建一个工作队列（动态创建）

_JobQueueDelete
	原型 : VOID  _jobQueueDelete (PLW_JOB_QUEUE pjobq)
	输入 : pjobq         工作队列控制块
	返回 : NONE
	说明 : 删除一个工作队列（动态创建）

_JobQueueInit
	原型 : ULONG  _jobQueueInit (PLW_JOB_QUEUE pjobq, 
	                             PLW_JOB_MSG   pjobmsg, 
	                             UINT          uiQueueSize, 
	                             BOOL          bNonBlock)
	输入 : pjobq             需要初始化的工作队列控制块
	       pjobmsg           消息缓冲区
	       uiQueueSize       队列大小
	       bNonBlock         执行函数是否为非阻塞方式
	返回 : 工作队列控制块
	说明 : 初始化一个工作队列 (静态创建)

_jobQueueFinit
	原型 : VOID  _jobQueueFinit (PLW_JOB_QUEUE pjobq)
	输入 : pjobq         工作队列控制块
	返回 : NONE
	说明 : 销毁一个工作队列 (静态销毁)

3.2 清空工作队列

清空工作队列的操作就是将指定工作队列控制块中的同步等待信号量清除，同时将工作队列的入队计数、出队计数和当前工作队列中消息数全部清零。

 _jobQueueFlush
	原型 : VOID  _jobQueueFlush (PLW_JOB_QUEUE pjobq)
	输入 : pjobq         工作队列控制块
	返回 : NONE
	说明 : 清空工作队列

3.3 添加工作

向一个工作队列中添加一个工作就是将一个工作消息保存到工作队列的消息管理成员，同时将该工作需要执行的回调函数及其参数保存到消息控制块中。

_JobQueueAdd
	原型 : ULONG  _jobQueueAdd (PLW_JOB_QUEUE pjobq,
	输入 : pjobq         工作队列控制块
	       pfunc         要执行的函数
	       pvArg0 ~ 5    函数参数
	返回 : ERROR
	说明 : 添加一个工作到工作队列

3.4 删除工作

删除工作队列中某一工作就是遍历工作队列消息列表，根据函数名及其参数个数匹配，将该工作的回调函数置空。

_JobQueueDel
	原型 : VOID  _jobQueueDel (PLW_JOB_QUEUE pjobq,
	输入 : pjobq         工作队列控制块
	       uiMatchArgNum 匹配参数的个数
	       pfunc         要删除的函数
	       pvArg0 ~ 5    函数参数
	返回 : NONE
	说明 : 从工作队列中删除一个工作 (懒惰删除)

3.5 获得丢失消息数量

当工作队列控制块中当前消息数量JOBQ_uiCnt等于工作队列总大小JOBQ_uiSize时，若此时又要向该工作队列中添加新的工作消息，则该工作消息会丢失并且丢失消息数量JOBQ_stLost将会加1，因此获取工作队列控制块的JOBQ_stLost的值即可获得当前丢失的消息数量。

_jobQueueLost
	原型 : ULONG  _jobQueueLost (PLW_JOB_QUEUE pjobq)
	输入 : pjobq         工作队列控制块
	返回 : NONE
	说明 : 获得工作队列丢失信息数量

3.6 执行工作

调用_jobQueueExec即可执行工作队列中的工作，其详细描述如下：

_jobQueueExec
	原型 : ULONG  _jobQueueExec (PLW_JOB_QUEUE pjobq, ULONG  ulTimeout)
	输入 : pjobq         工作队列控制块
	       ulTimeout     等待超时时间
	返回 : 不为 ERROR_NONE 表示超时
	说明 : 执行工作队列中的工作

执行工作队列中的工作就是判断工作队列中是否存在工作消息，若存在，则依次执行工作消息的回调函数，直至工作队列中的消息数量减为0。执行工作的具体流程如图 3.1所示。

异步工作队列执行工作流程

4、 程序源码

/*********************************************************************************************************
**
**                                    中国软件开源组织
**
**                                   嵌入式实时操作系统
**
**                                SylixOS(TM)  LW : long wing
**
**                               Copyright All Rights Reserved
**
**--------------文件信息--------------------------------------------------------------------------------
**
** 文   件   名: _JobQueue.c
**
** 创   建   人: Han.Hui (韩辉)
**
** 文件创建日期: 2013 年 12 月 01 日
**
** 描        述: 这是系统异步工作队列.
**
** BUG:
2018.01.05  _jobQueueDel() 如果 pfunc 参数为 NULL 则表示任意函数.
*********************************************************************************************************/
#define  __SYLIXOS_KERNEL
#include "../SylixOS/kernel/include/k_kernel.h"
/*********************************************************************************************************
  JOB MSG COPY
*********************************************************************************************************/
#define LW_JOB_MSG_COPY(t, f)                               \
        {                                                   \
            (t)->JOBM_pfuncFunc = (f)->JOBM_pfuncFunc;      \
            (t)->JOBM_pvArg[0]  = (f)->JOBM_pvArg[0];       \
            (t)->JOBM_pvArg[1]  = (f)->JOBM_pvArg[1];       \
            (t)->JOBM_pvArg[2]  = (f)->JOBM_pvArg[2];       \
            (t)->JOBM_pvArg[3]  = (f)->JOBM_pvArg[3];       \
            (t)->JOBM_pvArg[4]  = (f)->JOBM_pvArg[4];       \
            (t)->JOBM_pvArg[5]  = (f)->JOBM_pvArg[5];       \
        }
/*********************************************************************************************************
** 函数名称: _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);
}
/*********************************************************************************************************
** 函数名称: _JobQueueDelete
** 功能描述: 删除一个工作队列
** 输　入  : pjobq         工作队列控制块
** 输　出  : NONE
** 全局变量: 
** 调用模块: 
*********************************************************************************************************/
VOID  _jobQueueDelete (PLW_JOB_QUEUE pjobq)
{
    if (pjobq->JOBQ_ulSync) {
        API_SemaphoreBDelete(&pjobq->JOBQ_ulSync);
    }
    
    __KHEAP_FREE(pjobq);
}
/*********************************************************************************************************
** 函数名称: _JobQueueInit
** 功能描述: 初始化一个工作队列 (静态创建)
** 输　入  : pjobq             需要初始化的工作队列控制块
**           pjobmsg           消息缓冲区
**           uiQueueSize       队列大小
**           bNonBlock         执行函数是否为非阻塞方式
** 输　出  : 工作队列控制块
** 全局变量: 
** 调用模块: 
*********************************************************************************************************/
ULONG  _jobQueueInit (PLW_JOB_QUEUE pjobq, PLW_JOB_MSG  pjobmsg, UINT uiQueueSize, BOOL bNonBlock)
{
    pjobq->JOBQ_pjobmsgQueue = pjobmsg;
    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) {
            return  (errno);
        }
    }
    
    LW_SPIN_INIT(&pjobq->JOBQ_slLock);
    
    return  (ERROR_NONE);
}
/*********************************************************************************************************
** 函数名称: _jobQueueFinit
** 功能描述: 销毁一个工作队列 (静态销毁)
** 输　入  : pjobq         工作队列控制块
** 输　出  : NONE
** 全局变量: 
** 调用模块: 
*********************************************************************************************************/
VOID  _jobQueueFinit (PLW_JOB_QUEUE pjobq)
{
    if (pjobq->JOBQ_ulSync) {
        API_SemaphoreBDelete(&pjobq->JOBQ_ulSync);
    }
}
/*********************************************************************************************************
** 函数名称: _jobQueueFlush
** 功能描述: 清空工作队列
** 输　入  : pjobq         工作队列控制块
** 输　出  : NONE
** 全局变量: 
** 调用模块: 
*********************************************************************************************************/
VOID  _jobQueueFlush (PLW_JOB_QUEUE pjobq)
{
    INTREG   iregInterLevel;
    
    if (pjobq->JOBQ_ulSync) {
        API_SemaphoreBClear(pjobq->JOBQ_ulSync);
    }
    
    LW_SPIN_LOCK_QUICK(&pjobq->JOBQ_slLock, &iregInterLevel);
    
    pjobq->JOBQ_uiIn  = 0;
    pjobq->JOBQ_uiOut = 0;
    pjobq->JOBQ_uiCnt = 0;
    
    LW_SPIN_UNLOCK_QUICK(&pjobq->JOBQ_slLock, iregInterLevel);
}
/*********************************************************************************************************
** 函数名称: _JobQueueAdd
** 功能描述: 添加一个工作到工作队列
** 输　入  : pjobq         工作队列控制块
**           pfunc         要执行的函数
**           pvArg0 ~ 5    函数参数
** 输　出  : ERROR
** 全局变量: 
** 调用模块: 
*********************************************************************************************************/
ULONG  _jobQueueAdd (PLW_JOB_QUEUE pjobq,
                     VOIDFUNCPTR   pfunc,
                     PVOID         pvArg0,
                     PVOID         pvArg1,
                     PVOID         pvArg2,
                     PVOID         pvArg3,
                     PVOID         pvArg4,
                     PVOID         pvArg5)
{
    INTREG           iregInterLevel;
    PLW_JOB_MSG      pjobmsg;
    
    LW_SPIN_LOCK_QUICK(&pjobq->JOBQ_slLock, &iregInterLevel);
    if (pjobq->JOBQ_uiCnt == pjobq->JOBQ_uiSize) {
        pjobq->JOBQ_ulLost++;
        LW_SPIN_UNLOCK_QUICK(&pjobq->JOBQ_slLock, iregInterLevel);
        _DebugHandle(__ERRORMESSAGE_LEVEL, "job message lost.\r\n");
        return  (ENOSPC);
    }
    
    pjobmsg                 = &pjobq->JOBQ_pjobmsgQueue[pjobq->JOBQ_uiIn];
    pjobmsg->JOBM_pfuncFunc = pfunc;
    pjobmsg->JOBM_pvArg[0]  = pvArg0;
    pjobmsg->JOBM_pvArg[1]  = pvArg1;
    pjobmsg->JOBM_pvArg[2]  = pvArg2;
    pjobmsg->JOBM_pvArg[3]  = pvArg3;
    pjobmsg->JOBM_pvArg[4]  = pvArg4;
    pjobmsg->JOBM_pvArg[5]  = pvArg5;
    
    if (pjobq->JOBQ_uiIn == (pjobq->JOBQ_uiSize - 1)) {
        pjobq->JOBQ_uiIn =  0;
    } else {
        pjobq->JOBQ_uiIn++;
    }
    
    pjobq->JOBQ_uiCnt++;
    LW_SPIN_UNLOCK_QUICK(&pjobq->JOBQ_slLock, iregInterLevel);
    
    if (pjobq->JOBQ_ulSync) {
        API_SemaphoreBPost(pjobq->JOBQ_ulSync);
    }
    
    return  (ERROR_NONE);
}
/*********************************************************************************************************
** 函数名称: _JobQueueDel
** 功能描述: 从工作队列中删除一个工作 (懒惰删除)
** 输　入  : pjobq         工作队列控制块
**           uiMatchArgNum 匹配参数的个数
**           pfunc         要删除的函数
**           pvArg0 ~ 5    函数参数
** 输　出  : NONE
** 全局变量: 
** 调用模块: 
*********************************************************************************************************/
VOID  _jobQueueDel (PLW_JOB_QUEUE pjobq,
                    UINT          uiMatchArgNum,
                    VOIDFUNCPTR   pfunc, 
                    PVOID         pvArg0,
                    PVOID         pvArg1,
                    PVOID         pvArg2,
                    PVOID         pvArg3,
                    PVOID         pvArg4,
                    PVOID         pvArg5)
{
    INTREG          iregInterLevel;
    UINT            i = 0;
    PLW_JOB_MSG     pjobmsg;
    
    LW_SPIN_LOCK_QUICK(&pjobq->JOBQ_slLock, &iregInterLevel);
    pjobmsg = &pjobq->JOBQ_pjobmsgQueue[pjobq->JOBQ_uiOut];
    for (i = 0; i < pjobq->JOBQ_uiCnt; i++) {
        switch (uiMatchArgNum) {
        
        case 0:
            if (pjobmsg->JOBM_pfuncFunc == pfunc || !pfunc) {
                pjobmsg->JOBM_pfuncFunc =  LW_NULL;
            }
            break;
            
        case 1:
            if ((pjobmsg->JOBM_pfuncFunc == pfunc || !pfunc) &&
                (pjobmsg->JOBM_pvArg[0]  == pvArg0)) {
                pjobmsg->JOBM_pfuncFunc  =  LW_NULL;
            }
            break;
            
        case 2:
            if ((pjobmsg->JOBM_pfuncFunc == pfunc || !pfunc)  &&
                (pjobmsg->JOBM_pvArg[0]  == pvArg0) &&
                (pjobmsg->JOBM_pvArg[1]  == pvArg1)) {
                pjobmsg->JOBM_pfuncFunc  =  LW_NULL;
            }
            break;
            
        case 3:
            if ((pjobmsg->JOBM_pfuncFunc == pfunc || !pfunc)  &&
                (pjobmsg->JOBM_pvArg[0]  == pvArg0) &&
                (pjobmsg->JOBM_pvArg[1]  == pvArg1) &&
                (pjobmsg->JOBM_pvArg[2]  == pvArg2)) {
                pjobmsg->JOBM_pfuncFunc  =  LW_NULL;
            }
            break;
            
        case 4:
            if ((pjobmsg->JOBM_pfuncFunc == pfunc || !pfunc)  &&
                (pjobmsg->JOBM_pvArg[0]  == pvArg0) &&
                (pjobmsg->JOBM_pvArg[1]  == pvArg1) &&
                (pjobmsg->JOBM_pvArg[2]  == pvArg2) &&
                (pjobmsg->JOBM_pvArg[3]  == pvArg3)) {
                pjobmsg->JOBM_pfuncFunc  =  LW_NULL;
            }
            break;
            
        case 5:
            if ((pjobmsg->JOBM_pfuncFunc == pfunc || !pfunc)  &&
                (pjobmsg->JOBM_pvArg[0]  == pvArg0) &&
                (pjobmsg->JOBM_pvArg[1]  == pvArg1) &&
                (pjobmsg->JOBM_pvArg[2]  == pvArg2) &&
                (pjobmsg->JOBM_pvArg[3]  == pvArg3) &&
                (pjobmsg->JOBM_pvArg[4]  == pvArg4)) {
                pjobmsg->JOBM_pfuncFunc  =  LW_NULL;
            }
            break;
            
        case 6:
            if ((pjobmsg->JOBM_pfuncFunc == pfunc || !pfunc)  &&
                (pjobmsg->JOBM_pvArg[0]  == pvArg0) &&
                (pjobmsg->JOBM_pvArg[1]  == pvArg1) &&
                (pjobmsg->JOBM_pvArg[2]  == pvArg2) &&
                (pjobmsg->JOBM_pvArg[3]  == pvArg3) &&
                (pjobmsg->JOBM_pvArg[4]  == pvArg4) &&
                (pjobmsg->JOBM_pvArg[5]  == pvArg5)) {
                pjobmsg->JOBM_pfuncFunc  =  LW_NULL;
            }
            break;
        }
        pjobmsg++;
        if (pjobmsg > &pjobq->JOBQ_pjobmsgQueue[pjobq->JOBQ_uiSize - 1]) {
            pjobmsg = &pjobq->JOBQ_pjobmsgQueue[0];
        }
    }
    LW_SPIN_UNLOCK_QUICK(&pjobq->JOBQ_slLock, iregInterLevel);
}
/*********************************************************************************************************
** 函数名称: _jobQueueLost
** 功能描述: 获得工作队列丢失信息数量
** 输　入  : pjobq         工作队列控制块
** 输　出  : NONE
** 全局变量: 
** 调用模块: 
*********************************************************************************************************/
ULONG  _jobQueueLost (PLW_JOB_QUEUE pjobq)
{
    return  (pjobq->JOBQ_ulLost);
}
/*********************************************************************************************************
** 函数名称: _jobQueueExec
** 功能描述: 执行工作队列中的工作
** 输　入  : pjobq         工作队列控制块
**           ulTimeout     等待超时时间
** 输　出  : 不为 ERROR_NONE 表示超时
** 全局变量: 
** 调用模块: 
*********************************************************************************************************/
ULONG  _jobQueueExec (PLW_JOB_QUEUE pjobq, ULONG  ulTimeout)
{
    INTREG          iregInterLevel;
    PLW_JOB_MSG     pjobmsg;
    LW_JOB_MSG      jobmsgRun;
    
    if (pjobq->JOBQ_ulSync) {
        for (;;) {
            if (API_SemaphoreBPend(pjobq->JOBQ_ulSync, ulTimeout)) {
                return  (ERROR_THREAD_WAIT_TIMEOUT);
            }
            LW_SPIN_LOCK_QUICK(&pjobq->JOBQ_slLock, &iregInterLevel);
            if (pjobq->JOBQ_uiCnt) {
                break;
            }
            LW_SPIN_UNLOCK_QUICK(&pjobq->JOBQ_slLock, iregInterLevel);
        }
    } else {
        LW_SPIN_LOCK_QUICK(&pjobq->JOBQ_slLock, &iregInterLevel);
    }
    
    while (pjobq->JOBQ_uiCnt) {
        pjobmsg = &pjobq->JOBQ_pjobmsgQueue[pjobq->JOBQ_uiOut];
        LW_JOB_MSG_COPY(&jobmsgRun, pjobmsg);
        if (pjobq->JOBQ_uiOut == (pjobq->JOBQ_uiSize - 1)) {
            pjobq->JOBQ_uiOut =  0;
        } else {
            pjobq->JOBQ_uiOut++;
        }
        pjobq->JOBQ_uiCnt--;
        LW_SPIN_UNLOCK_QUICK(&pjobq->JOBQ_slLock, iregInterLevel);
        
        if (jobmsgRun.JOBM_pfuncFunc) {
            jobmsgRun.JOBM_pfuncFunc(jobmsgRun.JOBM_pvArg[0],
                                     jobmsgRun.JOBM_pvArg[1],
                                     jobmsgRun.JOBM_pvArg[2],
                                     jobmsgRun.JOBM_pvArg[3],
                                     jobmsgRun.JOBM_pvArg[4],
                                     jobmsgRun.JOBM_pvArg[5]);
        }
        
        LW_SPIN_LOCK_QUICK(&pjobq->JOBQ_slLock, &iregInterLevel);
    }
    LW_SPIN_UNLOCK_QUICK(&pjobq->JOBQ_slLock, iregInterLevel);
    
    return  (ERROR_NONE);
}
/*********************************************************************************************************
  END
*********************************************************************************************************/
ScilogyHunter
关注
专栏目录
Linux驱动开发-内核共享工作队列
03-28 445
工作队列常见的使用形式是配合中断使用，在中断的服务函数里无法调用会导致休眠的相关函数代码，有了工作队列机制以后，可以将需要执行的逻辑代码放在工作队列里执行，只需要在中断服务函数里触发即可，工作队列是允许被重新调度、睡眠。
SylixOS 经得起检验的国产操作系统 （三）
sun_junhui的博客
07-08 5985
本篇文章将介绍SylixOS软件框架以及POSIX标准。SylixOS官网：http://www.sylixos.com。
内核工作队列workqueue
weixin_34307464的博客
03-05 182
2019独角兽企业重金招聘Python工程师标准>>> ...
内核工作队列
最新发布
d0203的博客
08-12 860
参考内核头文件structstruct0第1个宏是用来定义一个结构体，要指定它的函数。第2个宏用来定义一个结构体，也要指定它的函数。所以delayed，意思就是说要让它运行时，可以指定：某段时间之后再执行。如果要在代码中初始化0。
SylixOS 异步工作队列
GOOD GOOD STUDY
10-23 435
本篇主要介绍SylixOS中异步工作队列（JobQueue）的原理及相关函数接口。
内核的工作队列
qq_39236383的博客
07-21 379
工作队列 前面讲的定时器、下半部 tasklet，它们都是在中断上下文中执行，它们无法休眠。当要处理更复杂的 事情时，往往更耗时。这些更耗时的工作放在定时器或是下半部中，会使得系统很卡；并且循环等待某件事 情完成也太浪费 CPU 资源了。 如果使用线程来处理这些耗时的工作，那就可以解决系统卡顿的问题：因为线程可以休眠。 在内核中，我们并不需要自己去创建线程，可以使用“工作队列”(workqueue)。内核初始化工作队列 是，就为它创建了内核线程。以后我们要使用“工作队列”，只需要把“工作”放入“工作队列中”
linux内核之工作队列
huangweiqing80的博客
10-23 1507
在我的文章Linux内核：软中断、tasklet中，我们已经了解了中断底半部的两种实现方式，即软中断和tasklet微线程。但是这两种方式归根结底都是采用软中断机制的，其根本上还是在中断的上下文中执行，所以这也就要求了采用这两种方式编写中断底半部，不能出现一些可能导致程序休眠或者是延迟的函数（虽然当发生中断嵌套时会生成Ksoftirq线程，但这个是不确定的，所以我们在编写程序时，还是不能采用具有休...
SylixOS实验指导书1
08-08
SylixOS 提供了丰富的内核服务，如任务管理、信号量、消息队列、内存管理等．它支持多种处理器架构，包括ARM，能够满足不同硬件平台的需求．此外，SylixOS 支持硬实时和软实时应用，适用于工业自动化、航空航天、...
SylixOS can驱动框架分析
12-24
此函数的具体实现细节未在文档中给出，但可以推测它主要负责配置必要的系统资源，并确保CAN驱动能够正确地与SylixOS内核进行交互。 ##### 2. API_CanDevCreate函数 `API_CanDevCreate`函数是创建CAN设备的核心函数...
SylixOS上EtherCAT实现
Jackstraw瑞的博客
11-01 3019
1 EtherCAT开源协议栈介绍     目前常见开源的主站代码为RT-LAB开发的SOEM(Simple OpenSource EtherCAT Master)和EtherLab的the IgH EtherCAT® Master，SylixOS对两者都支持。其中IgH作为常用的EtherCAT开源协议栈，SylixOS已移植支持。 2 SylixOS-IgH使用框架     SylixO
SylixOS 经得起检验的国产操作系统 （二）
sun_junhui的博客
06-30 4559
这里继续介绍国产嵌入式操作系统SylixOS。目前本系统是以公开源代码项目的形式存在，感兴趣或想进一步了解的读者请访问官网：http://www.sylixos.com。随时可以下载使用，同时还可以很方便的申请“体验版集成开发环境套件”（目前是“有求必应”的哦）。 适合应用领域         SylixOS采用抢占式多任务硬实时的方式来设计整个操作系统。其技术实现的核心目标是实时可控，稳定可
linux内核工作队列demo
07-01
很多博客都有深入分析内核队列的工作原理，但是少有能够拿来直接运行的demo，这个demo亲测可用！
2K 龙芯派翼辉 SylixOS 操作系统使用手册
04-29
SylixOS 是国内一款内核自主化率达到 100% 的开源大型实时操作系统；支持 ARM、 MIPS、PowerPC、x86、SPARC、DSP 等处理器架构，便于在不同硬件平台之间进行系统迁 移；硬实时内核，调度算法先进高效，性能强劲；应用编程接口符合 IEEE、 ISO、 IEC 、 GJB7714-2012 相关操作系统编程接口规范，便于基于 Linux、VxWorks 等操作系统应用向 SylixOS 系统的迁移。 SylixOS 提供一整套集设计、开发、调试、仿真、部署、测试于一体的开发平台，便于 系统开发与调试，加快软件研发速度，缩短产品研制周期，助力用户专注应用开发。
Linux内核实践之工作队列
bullbat的专栏
03-30 7530
工作队列（work queue）是另外一种将工作推后执行的形式，它和tasklet有所不同。工作队列可以把工作推后，交由一个内核线程去执行，也就是说，这个下半部分可以在进程上下文中执行。这样，通过工作队列执行的代码能占尽进程上下文的所有优势。最重要的就是工作队列允许被重新调度甚至是睡眠。          那么，什么情况下使用工作队列，什么情况下使用tasklet。如果推后执行的任务需
SylixOS 系统工作队列
ScilogyHunter的博客
09-14 504
1、概述 在内核代码中，经常希望将部分工作推迟到将来的某个时间执行，这样做的原因有很多，比如： 在持有锁的情况下做耗时操作； 希望将工作集中起来以获取批处理的性能； 调用了可能导致睡眠的函数。 SylixOS 内核提供了一种机制来提供延迟执行的功能，即工作队列。工作队列是将操作延期执行的一种手段。工作队列可以把工作推后，交由一个内核线程去执行，并且工作队列是执行在进程上下文中，因此工作队列可以被重新调度和抢占甚至睡眠。工作队列的应用场景有很多：比如需要在中断（下半部）里面要做很多的耗时操作，这时就可以把
Linux 内核中工作队列的操作
weixin_30552811的博客
11-16 78
工作队列(workqueue)的Linux内核中的定义的用来处理不是很紧急事件的回调方式处理方法. 　　以下代码的linux内核版本为2.6.19.2, 源代码文件主要为kernel/workqueue.c. 　　2. 数据结构 　　/* include/linux/workqueue.h */　　// 工作节点结构　　struct work_struct {　　// 等待时间　　u...
内核中工作队列（linux工作队列）
雜貨鋪
08-12 811
原文地址：http://gqf2008.iteye.com/blog/447060   Linux自从2.6.20之后，工作队列发生了一些变化，目前从网络上搜索的资料一般都是介绍老版本的工作队列，很少见到对新版本的介绍。本文对新老版本都做了简要概述，并分别提供了简单的实作案例。 工作队列(work queue)是Linux kernel中将工作推后执行的一种机制。这种机制和B
Linux内核工作队列
姥姥教我学编程
06-13 767
Linux内核工作队列
SylixOS内核启动参数详解与驱动开发
"SylixOS内核启动参数的设置方法及其在驱动开发中的重要性" SylixOS是一款先进的实时嵌入式操作系统，广泛应用于航空航天、工业自动化、通信和新能源领域。在开发SylixOS驱动时，了解内核启动参数的设置至关重要。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

ScilogyHunter

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值