任務的基本概念

從系統的角度看，任務是競爭系統資源的最小運行單元，TencentOS tiny是一個支持多任務的作業系統，任務可以使用或等待CPU、使用記憶體空間等系統資源，并獨立于其它任務運行，理論上任何數量的任務都可以共享同一個優先級，這樣子處于就緒態的多個相同優先級任務將會以時間片切換的方式共享處理器，

不過要注意的是：在TencentOS tiny中，不能創建與空閑任務相同優先級的任務K_TASK_PRIO_IDLE，相同優先級下的任務需要允許使用時間片調度，打開TOS_CFG_ROUND_ROBIN_EN，

簡而言之： TencentOS tiny的任務可認為是一系列獨立任務的集合，每個任務在自己的環境中運行，在任何時刻，只有一個任務得到運行，由TencentOS tiny調度器決定運行哪個任務，從宏觀看上去所有的任務都在同時在執行，

TencentOS中的任務是搶占式調度機制，高優先級的任務可打斷低優先級任務，低優先級任務必須在高優先級任務阻塞或結束后才能得到調度，同時TencentOS也支持時間片輪轉調度方式，

系統默認可以支持10個優先級，0～TOS_CFG_TASK_PRIO_MAX，這個宏定義是可以修改的，優先級數值越大的任務優先級越低，(TOS_CFG_TASK_PRIO_MAX - (k_prio_t)1u)為最低優先級，分配給空閑任務使用，

#define K_TASK_PRIO_IDLE         (k_prio_t)(TOS_CFG_TASK_PRIO_MAX - (k_prio_t)1u)
#define K_TASK_PRIO_INVALID      (k_prio_t)(TOS_CFG_TASK_PRIO_MAX)

任務狀態

TencentOS tiny任務狀態有以下幾種，

就緒態（K_TASK_STATE_READY）：該任務在就緒串列中，就緒的任務已經具備執行的能力，只等待調度器進行調度，新創建的任務會初始化為就緒態，
運行態（K_TASK_STATE_READY）：該狀態表明任務正在執行，此時它占用處理器，其實此時的任務還是處于就緒串列中的，TencentOS調度器選擇運行的永遠是處于最高優先級的就緒態任務，當任務被運行的一刻，它的任務狀態就變成了運行態，
睡眠態（K_TASK_STATE_SLEEP）：如果任務當前正在休眠讓出CPU使用權，那么就可以說這個任務處于休眠狀態，該任務不在就緒串列中，此時任務處于睡眠串列中（或者叫延時串列），
等待態（K_TASK_STATE_PEND）：任務正在等待信號量、佇列或者等待事件等狀態，
掛起態（K_TASK_STATE_SUSPENDED）：任務被掛起，此時任務對調度器而言是不可見的，
退出態（K_TASK_STATE_DELETED）：該任務運行結束，并且被洗掉，
等待超時狀態（K_TASK_STATE_PENDTIMEOUT）：任務正在等待信號量、佇列或者等待事件發生超時的狀態，
睡眠掛起態（K_TASK_STATE_SLEEP_SUSPENDED）：任務在睡眠中被掛起時的狀態，
等待掛起態（K_TASK_STATE_PEND_SUSPENDED）：任務正在等待信號量、佇列或者等待事件時被掛起的狀態，
等待超時掛起態（K_TASK_STATE_PENDTIMEOUT_SUSPENDED）：任務正在等待信號量、佇列或者等待事件發生超時，但此時任務已經被掛起的狀態，

// ready to schedule
// a task's pend_list is in readyqueue
#define K_TASK_STATE_READY                (k_task_state_t)0x0000

// delayed, or pend for a timeout
// a task's tick_list is in k_tick_list
#define K_TASK_STATE_SLEEP                (k_task_state_t)0x0001

// pend for something
// a task's pend_list is in some pend object's list
#define K_TASK_STATE_PEND                 (k_task_state_t)0x0002

// suspended
#define K_TASK_STATE_SUSPENDED            (k_task_state_t)0x0004

// deleted
#define K_TASK_STATE_DELETED              (k_task_state_t)0x0008

// actually we don't really need those TASK_STATE below, if you understand the task state deeply, the code can be much more elegant. 

// we are pending, also we are waitting for a timeout(eg. tos_sem_pend with a valid timeout, not TOS_TIME_FOREVER)
// both a task's tick_list and pend_list is not empty
#define K_TASK_STATE_PENDTIMEOUT                      (k_task_state_t)(K_TASK_STATE_PEND | K_TASK_STATE_SLEEP)

// suspended when sleeping
#define K_TASK_STATE_SLEEP_SUSPENDED                  (k_task_state_t)(K_TASK_STATE_SLEEP | K_TASK_STATE_SUSPENDED)

// suspened when pending
#define K_TASK_STATE_PEND_SUSPENDED                   (k_task_state_t)(K_TASK_STATE_PEND | K_TASK_STATE_SUSPENDED)

// suspended when pendtimeout
#define K_TASK_STATE_PENDTIMEOUT_SUSPENDED            (k_task_state_t)(K_TASK_STATE_PENDTIMEOUT | K_TASK_STATE_SUSPENDED)

TencentOS中維護任務的資料結構

就緒串列

TencentOS tiny維護一條就緒串列，用于掛載系統中的所有處于就緒態的任務，他是readyqueue_t 型別的串列，其成員變數如下：

readyqueue_t        k_rdyq;

typedef struct readyqueue_st {
    k_list_t    task_list_head[TOS_CFG_TASK_PRIO_MAX];
    uint32_t    prio_mask[K_PRIO_TBL_SIZE];
    k_prio_t    highest_prio;
} readyqueue_t;

task_list_head是串列型別k_list_t的陣列，TencentOS tiny為每個優先級的任務都分配一個串列，系統支持最大優先級為TOS_CFG_TASK_PRIO_MAX
prio_mask則是優先級掩碼陣列，它是一個型別為32位變數的陣列，陣列成員個數由TOS_CFG_TASK_PRIO_MAX決定：

#define K_PRIO_TBL_SIZE         ((TOS_CFG_TASK_PRIO_MAX + 31) / 32)

當TOS_CFG_TASK_PRIO_MAX不超過32時陣列成員變數只有一個，就是32位的變數數值，那么該變數的每一位代表一個優先級，比如當TOS_CFG_TASK_PRIO_MAX為64時，prio_mask[0]變數的每一位（bit）代表0-31優先級，而prio_mask[1]變數的每一位代表32-63優先級，

highest_prio則是記錄當前優先級串列的最高優先級，方便索引task_list_head，

延時串列

與系統時間相關的任務都會被掛載到這個串列中，可能是睡眠、有期限地等待信號量、事件、訊息佇列等情況~

k_list_t             k_tick_list;

任務控制塊

在多任務系統中，任務的執行是由系統調度的，系統為了順利的調度任務，為每個任務都額外定義了一個任務控制塊，這個任務控制塊就相當于任務的身份證，里面存有任務的所有資訊，比如任務的堆疊指標，任務名稱，任務的形參等，有了這個任務控制塊之后，以后系統對任務的全部操作都可以通過這個任務控制塊來實作，
TencentOS 任務控制塊如下：

typedef struct k_task_st {
    k_stack_t          *sp;                 /**< 任務堆疊指標,用于切換背景關系*/

#if TOS_CFG_OBJECT_VERIFY_EN > 0u
    knl_obj_t           knl_obj;            /**< 只是為了驗證，測驗當前物件是否真的是一項任務，*/
#endif

    char               *name;               /**< 任務名稱 */
    k_task_entry_t      entry;              /**< 任務主體 */
    void               *arg;                /**< 任務主體形參 */
    k_task_state_t      state;              /**< 任務狀態 */
    k_prio_t            prio;               /**< 任務優先級 */

    k_stack_t          *stk_base;           /**< 任務堆疊基地址 */
    size_t              stk_size;           /**< 任務堆疊大小 */

    k_tick_t            tick_expires;       /**< 任務阻塞的時間 */

    k_list_t            tick_list;          /**< 延時串列 */
    k_list_t            pend_list;          /**< 就緒、等待串列 */

#if TOS_CFG_MUTEX_EN > 0u
    k_list_t            mutex_own_list;     /**< 任務擁有的互斥量 */
    k_prio_t            prio_pending;       /*< 用于記錄持有互斥量的任務初始優先級，在優先級繼承中使用 */
#endif

    pend_obj_t         *pending_obj;       /**< 記錄任務此時掛載到的串列 */
    pend_state_t        pend_state;         /**< 等待被喚醒的原因（狀態） */

#if TOS_CFG_ROUND_ROBIN_EN > 0u
    k_timeslice_t       timeslice_reload;   /**< 時間片初始值（重裝載值） */
    k_timeslice_t       timeslice;          /**< 剩余時間片 */
#endif

#if TOS_CFG_MSG_EN > 0u
    void               *msg_addr;           /**< 保存接收到的訊息 */
    size_t              msg_size;			/**< 保存接收到的訊息大小 */
#endif

#if TOS_CFG_EVENT_EN > 0u
    k_opt_t             opt_event_pend;     /**< 等待事件的的操作型別：TOS_OPT_EVENT_PEND_ANY 、 TOS_OPT_EVENT_PEND_ALL */
    k_event_flag_t      flag_expect;        /**< 期待發生的事件 */
    k_event_flag_t     *flag_match;         /**< 等待到的事件 */
#endif
} k_task_t;

創建任務

在TencentOS tiny中，凡是使用__API__ 修飾的函式都是提供給用戶使用的，而使用__KERNEL__修飾的代碼則是給內核使用的，
TencentOS的創建任務函式有好幾個引數：

引數	含義
task	任務控制塊
name	任務名字
entry	任務主體
arg	任務形參
prio	優先級
stk_base	任務堆疊基地址
stk_size	任務堆疊大小
timeslice	時間片

引數詳解（來源TencentOS tiny開發指南）：

task

這是一個k_task_t型別的指標，k_task_t是內核的任務結構體型別，注意：task指標，應該指向生命周期大于待創建任務體生命周期的k_task_t型別變數，如果該指標指向的變數生命周期比待創建的任務體生命周期短，譬如可能是一個生命周期極端的函式堆疊上變數，可能會出現任務體還在運行而k_task_t變數已被銷毀，會導致系統調度出現不可預知問題，
name

指向任務名字串的指標，注意：同task，該指標指向的字串生命周期應該大于待創建的任務體生命周期，一般來說，傳入字串常量指標即可，
entry

任務體運行的函式入口，當任務創建完畢進入運行狀態后，entry是任務執行的入口，用戶可以在此函式中撰寫業務邏輯，
arg

傳遞給任務入口函式的引數，
prio

任務優先級，prio的數值越小，優先級越高，用戶可以在tos_config.h中，通過TOS_CFG_TASK_PRIO_MAX來配置任務優先級的最大數值，在內核的實作中，idle任務的優先級會被分配為TOS_CFG_TASK_PRIO_MAX - 1,此優先級只能被idle任務使用，因此對于一個用戶創建的任務來說，合理的優先級范圍應該為[0, TOS_CFG_TASK_PRIO_MAX - 2]，另外TOS_CFG_TASK_PRIO_MAX的配置值必需大于等于8，
stk_base

任務在運行時使用的堆疊空間的起始地址，注意：同task，該指標指向的記憶體空間的生命周期應該大于待創建的任務體生命周期，stk_base是k_stack_t型別的陣列起始地址，
stk_size

任務的堆疊空間大小，注意：因為stk_base是k_stack_t型別的陣列指標，因此實際堆疊空間所占記憶體大小為stk_size * sizeof(k_stack_t)，
timeslice

時間片輪轉機制下當前任務的時間片大小，當timeslice為0時，任務調度時間片會被設定為默認大小（TOS_CFG_CPU_TICK_PER_SECOND / 10），系統時鐘滴答（systick）數 / 10，

創建任務的實作如下：首先對引數進行檢查，還要再提一下：在TencentOS中，不能創建與空閑任務相同優先級的任務K_TASK_PRIO_IDLE，然后呼叫cpu_task_stk_init函式將任務堆疊進行初始化，并且將傳入的引數記錄到任務控制塊中，如果打開了TOS_CFG_ROUND_ROBIN_EN 宏定義，則表示支持時間片調度，則需要配置時間片相關的資訊timeslice 到任務控制塊中，然后呼叫task_state_set_ready函式將新創建的任務設定為就緒態K_TASK_STATE_READY，再呼叫readyqueue_add_tail函式將任務插入就緒串列k_rdyq中，如果調度器運行起來了，則進行一次任務調度，

個人感覺吧，沒有從堆中動態分配還是有點小小的遺憾，我更喜歡簡單的函式介面~！

代碼如下：

__API__ k_err_t tos_task_create(k_task_t *task,
                                char *name,
                                k_task_entry_t entry,
                                void *arg,
                                k_prio_t prio,
                                k_stack_t *stk_base,
                                size_t stk_size,
                                k_timeslice_t timeslice)
{
    TOS_CPU_CPSR_ALLOC();

    TOS_IN_IRQ_CHECK();

    TOS_PTR_SANITY_CHECK(task);
    TOS_PTR_SANITY_CHECK(entry);
    TOS_PTR_SANITY_CHECK(stk_base);

    if (unlikely(stk_size < sizeof(cpu_context_t))) {
        return K_ERR_TASK_STK_SIZE_INVALID;
    }

    if (unlikely(prio == K_TASK_PRIO_IDLE && !knl_is_idle(task))) {
        return K_ERR_TASK_PRIO_INVALID;
    }

    if (unlikely(prio > K_TASK_PRIO_IDLE)) {
        return K_ERR_TASK_PRIO_INVALID;
    }

    task_reset(task);
#if TOS_CFG_OBJECT_VERIFY_EN > 0u
    knl_object_init(&task->knl_obj, KNL_OBJ_TYPE_TASK);
#endif

    task->sp        = cpu_task_stk_init((void *)entry, arg, (void *)task_exit, stk_base, stk_size);
    task->entry     = entry;
    task->arg       = arg;
    task->name      = name;
    task->prio      = prio;
    task->stk_base  = stk_base;
    task->stk_size  = stk_size;

#if TOS_CFG_ROUND_ROBIN_EN > 0u
    task->timeslice_reload = timeslice;

    if (timeslice == (k_timeslice_t)0u) {
        task->timeslice = k_robin_default_timeslice;
    } else {
        task->timeslice = timeslice;
    }
#endif

    TOS_CPU_INT_DISABLE();
    task_state_set_ready(task);
    readyqueue_add_tail(task);
    TOS_CPU_INT_ENABLE();

    if (tos_knl_is_running()) {
        knl_sched();
    }

    return K_ERR_NONE;
}

任務銷毀

這個函式十分簡單，根據傳遞進來的任務控制塊銷毀任務，也可以傳遞進NULL表示銷毀當前運行的任務，但是不允許銷毀空閑任務k_idle_task，當調度器被鎖住時不能銷毀自身，會回傳K_ERR_SCHED_LOCKED錯誤代碼，如果使用了互斥量，當任務被銷毀時會釋放掉互斥量，并且根據任務所處的狀態進行銷毀，比如任務處于就緒態、延時態、等待態，則會從對應的狀態串列中移除，
代碼實作如下：

__API__ k_err_t tos_task_destroy(k_task_t *task)
{
    TOS_CPU_CPSR_ALLOC();

    TOS_IN_IRQ_CHECK();

    if (unlikely(!task)) {
        task = k_curr_task;
    }

#if TOS_CFG_OBJECT_VERIFY_EN > 0u
    if (!knl_object_verify(&task->knl_obj, KNL_OBJ_TYPE_TASK)) {
        return K_ERR_OBJ_INVALID;
    }
#endif

    if (knl_is_idle(task)) {
        return K_ERR_TASK_DESTROY_IDLE;
    }

    if (knl_is_self(task) && knl_is_sched_locked()) {
        return K_ERR_SCHED_LOCKED;
    }

    TOS_CPU_INT_DISABLE();

#if TOS_CFG_MUTEX_EN > 0u
    // when we die, wakeup all the people in this land.
    if (!tos_list_empty(&task->mutex_own_list)) {
        task_mutex_release(task);
    }
#endif

    if (task_state_is_ready(task)) { // that's simple, good kid
        readyqueue_remove(task);
    }
    if (task_state_is_sleeping(task)) {
        tick_list_remove(task);
    }
    if (task_state_is_pending(task)) {
        pend_list_remove(task);
    }

    task_reset(task);
    task_state_set_deleted(task);

    TOS_CPU_INT_ENABLE();
    knl_sched();

    return K_ERR_NONE;
}

任務睡眠

任務睡眠非常簡單，主要的思路就是將任務從就緒串列移除，然后添加到延時串列中k_tick_list，如果調度器被鎖，直接回傳錯誤代碼K_ERR_SCHED_LOCKED，如果睡眠時間為0，則呼叫tos_task_yield函式發起一次任務調度；呼叫tick_list_add函式將任務插入延時串列中，睡眠的時間delay是由用戶指定的，不過需要注意的是如果任務睡眠的時間是永久睡眠TOS_TIME_FOREVER，將回傳錯誤代碼K_ERR_DELAY_FOREVER，這是因為任務睡眠是主動行為，如果永久睡眠了，將沒法主動喚醒，而任務等待事件、信號量、訊息佇列等行為是被動行為，可以是永久等待，一旦事件發生了、信號量唄釋放、訊息佇列不為空時任務就會被喚醒，這是被動行為，這兩點需要區分開來，最后呼叫readyqueue_remove函式將任務從就緒串列中移除，然后呼叫knl_sched函式發起一次任務調度，就能切換另一個任務，
任務睡眠的代碼如下：

__API__ k_err_t tos_task_delay(k_tick_t delay)
{
    TOS_CPU_CPSR_ALLOC();

    TOS_IN_IRQ_CHECK();

    if (knl_is_sched_locked()) {
        return K_ERR_SCHED_LOCKED;
    }

    if (unlikely(delay == (k_tick_t)0u)) {
        tos_task_yield();
        return K_ERR_NONE;
    }

    TOS_CPU_INT_DISABLE();

    if (tick_list_add(k_curr_task, delay) != K_ERR_NONE) {
        TOS_CPU_INT_ENABLE();
        return K_ERR_DELAY_FOREVER;
    }

    readyqueue_remove(k_curr_task);

    TOS_CPU_INT_ENABLE();
    knl_sched();

    return K_ERR_NONE;
}

喜歡就關注我吧！

歡迎關注我公眾號

相關代碼可以在公眾號后臺獲取，
更多資料歡迎關注“物聯網IoT開發”公眾號！

轉載請註明出處，本文鏈接：https://www.uj5u.com/caozuo/30529.html

標籤：嵌入式

上一篇：【TencentOS tiny】超詳細的TencentOS tiny移植到STM32F103全教程

下一篇：【TencentOS tiny】深度原始碼分析（2）——調度器

【TencentOS tiny】深度原始碼分析（1）——task