modify XiUOS DIR : (1.add plc_demo in APP_Framework/control_app; 2.add industrial_network、industrial_fieldbus and industrial_wlan; 3.add XiZi_AIoT and modify XiZi as XiZi_IIoT.)

2022-09-27 20:39:52 +08:00
parent dbca22a1a6
commit e14fa6ff8e
5009 changed files with 1019 additions and 3084 deletions
@@ -0,0 +1,487 @@
+/*
+* Copyright (c) 2020 AIIT XUOS Lab
+* XiUOS is licensed under Mulan PSL v2.
+* You can use this software according to the terms and conditions of the Mulan PSL v2.
+* You may obtain a copy of Mulan PSL v2 at:
+*        http://license.coscl.org.cn/MulanPSL2
+* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+* See the Mulan PSL v2 for more details.
+*/
+
+/**
+* @file:    smp_assign.c
+* @brief:   system scheduler of multiple cpu
+* @version: 1.0
+* @author:  AIIT XUOS Lab
+* @date:    2020/3/15
+*
+*/
+
+#include <xs_isr.h>
+#include <xs_spinlock.h>
+#include <xs_ktask_stat.h>
+#include <xs_assign.h>
+#include <xs_hook.h>
+#include <stdio.h>
+
+struct Assign Assign;
+HwSpinlock AssignSpinLock;
+
+static struct PriorityReadyVectorDone ready_vector_done =
+{
+    OsAssignReadyVectorInit,
+    KTaskInsertToReadyVector,
+    KTaskOsAssignRemoveKTask,
+};
+
+static inline x_ubase SmpGetReadyVectorHighestPrio(void)
+{
+    uint8 coreid = GetCpuId();
+
+    return ((Assign.os_assign_read_vector.highest_prio > Assign.smp_os_assign_ready_rector[coreid].highest_prio) ? Assign.os_assign_read_vector.highest_prio : Assign.smp_os_assign_ready_rector[coreid].highest_prio);
+}
+
+/*
+ * get target highest priority task in ready queue
+ */
+static inline struct TaskDescriptor* SmpAssignTargetTaskSelect(void)
+{
+
+    uint8 coreid = GetCpuId();
+
+    if (Assign.os_assign_read_vector.highest_prio > Assign.smp_os_assign_ready_rector[coreid].highest_prio)
+    {
+        return ChooseTaskWithHighestPrio(&Assign.os_assign_read_vector);
+    }
+    else
+    {
+        return ChooseTaskWithHighestPrio(&Assign.smp_os_assign_ready_rector[coreid]);
+    }
+}
+
+static inline void SmpOsAssignSwtichToNewTask(struct TaskDescriptor* old_task, struct TaskDescriptor* new_task)
+{
+    NULL_PARAM_CHECK(old_task);
+    NULL_PARAM_CHECK(new_task);
+
+    Assign.ready_vector_done->remove(new_task);
+    KTaskStatSetAsRunning(new_task);
+
+#ifdef USING_OVERFLOW_CHECK
+    _KTaskOsAssignStackCheck(new_task);
+#endif
+
+    SwitchKtaskContext((x_ubase)&old_task->stack_point, (x_ubase)&new_task->stack_point, new_task);
+}
+
+static inline void SmpSwitchToFirstRunningTask(struct TaskDescriptor* task)
+{
+    NULL_PARAM_CHECK(task);
+
+    Assign.ready_vector_done->remove(task);
+    KTaskStatSetAsRunning(task);
+    
+    SwitchKtaskContextTo((x_ubase)&task->stack_point, task);
+
+}
+
+static inline void SetSystemRunningTask(struct TaskDescriptor* task)
+{
+    NULL_PARAM_CHECK(task);
+
+    task->task_smp_info.runing_coreid = GetCpuId();
+}
+
+static void SmpOsAssignInit(void)
+{
+    int coreid = 0;
+    while(coreid < CPU_NUMBERS) {
+        Assign.ready_vector_done->init(&Assign.smp_os_assign_ready_rector[coreid]);
+        Assign.smp_os_running_task[coreid] = NONE;
+        
+#ifdef ARCH_SMP
+        isrManager.isr_switch_trigger_flag[coreid] = 0;
+#else
+        isrManager.isr_switch_trigger_flag = 0;
+#endif
+        Assign.current_priority[coreid] = KTASK_PRIORITY_MAX - 1;
+        Assign.assign_lock[coreid] = 0;
+        coreid++;
+    }
+}
+
+struct smp_assign_done smp_assign_done =
+{
+    SmpGetReadyVectorHighestPrio,
+    SmpAssignTargetTaskSelect,
+    SmpOsAssignSwtichToNewTask,
+    SmpSwitchToFirstRunningTask,
+    SetSystemRunningTask,
+    SmpOsAssignInit,
+};
+
+
+
+/**
+ * task schedule function.getting the highest priority task then switching to it
+ */
+void KTaskOsAssign(void)
+{
+    x_base lock = 0;
+    int coreid = 0;
+    x_ubase highest_prio = 0;
+    struct TaskDescriptor *new_task = NONE;
+    struct TaskDescriptor *runningtask = NONE;
+    
+    coreid = GetCpuId();
+    if (isrManager.done->isInIsr()) {
+        isrManager.done->setSwitchTrigerFlag();
+        return;
+    }
+
+    if(Assign.assign_lock[coreid] >= 1) {
+        return;
+    }
+    
+    runningtask = Assign.smp_os_running_task[coreid];
+
+    /* if the bitmap is empty then do not switch */
+    if((RET_TRUE == JudgeAssignReadyBitmapIsEmpty(&Assign.os_assign_read_vector)) &&
+        (RET_TRUE == JudgeAssignReadyBitmapIsEmpty(&Assign.smp_os_assign_ready_rector[coreid]))) {
+        return;
+    }
+
+    highest_prio = Assign.smp_assign_done->GetHighest();
+    new_task = Assign.smp_assign_done->select();
+ 
+
+    if(RET_TRUE != JudgeKTaskStatIsRunning(runningtask)) {
+        CHECK(NONE != new_task);
+        goto SWITCH;
+    }
+    /* if the running task’ priority is the highest and this task is not be yield then do not switch */
+    if(highest_prio < runningtask->task_dync_sched_member.cur_prio) {
+        return;
+    } else {   
+        Assign.ready_vector_done->insert(runningtask);
+    }
+SWITCH:
+
+    new_task->task_smp_info.runing_coreid = coreid;
+    Assign.current_priority[coreid] = (uint8)highest_prio;
+
+    HOOK(hook.assign.hook_Assign,(runningtask, new_task));
+
+    SYS_KDEBUG_LOG(KDBG_SCHED,
+            ("[%d]switch to priority#%d "
+                "task:%.*s(sp:0x%08x), "
+                "from task:%.*s(sp: 0x%08x)\n",
+                isrManager.done->getCounter(), highest_prio,
+                NAME_NUM_MAX, new_task->task_base_info.name, new_task->stack_point,
+                NAME_NUM_MAX, runningtask->task_base_info.name, runningtask->stack_point));
+
+    Assign.smp_assign_done->SwitchToNew(runningtask,new_task);
+}
+
+/**
+ * task  switch in IRQ context. 
+ */
+void KTaskOsAssignDoIrqSwitch(void *context)
+{
+    int coreid = 0;
+    x_base lock = 0;
+    x_ubase highest_priority = 0;
+    struct TaskDescriptor *new_task = NONE;
+    struct TaskDescriptor *runningtask = NONE;
+    
+    coreid = GetCpuId();
+    if ( isrManager.done->getSwitchTrigerFlag() == 0) {
+        return;
+    }
+
+    if (Assign.assign_lock[coreid] >= 1 || isrManager.done->getCounter() != 0) {
+        return;
+    }
+
+    
+    isrManager.done->clearSwitchTrigerFlag();
+
+    runningtask = Assign.smp_os_running_task[coreid];
+
+    if((RET_TRUE == JudgeAssignReadyBitmapIsEmpty(&Assign.os_assign_read_vector)) &&
+        (RET_TRUE == JudgeAssignReadyBitmapIsEmpty(&Assign.smp_os_assign_ready_rector[coreid]))) {
+        return;
+    }
+
+    highest_priority = Assign.smp_assign_done->GetHighest();
+    new_task = Assign.smp_assign_done->select();
+
+    if (RET_TRUE == JudgeKTaskStatIsRunning(runningtask)) {
+        if (runningtask->task_dync_sched_member.cur_prio > highest_priority) {
+            new_task = runningtask;
+        } else {
+            Assign.ready_vector_done->insert(runningtask);
+        }
+    }
+
+    new_task->task_smp_info.runing_coreid = coreid;
+    if (new_task != runningtask) {
+       Assign.current_priority[coreid] = (uint8)highest_priority;
+       HOOK(hook.assign.hook_Assign, (runningtask, new_task));
+       Assign.ready_vector_done->remove(new_task);
+       KTaskStatSetAsRunning(new_task);
+
+#ifdef KERNEL_STACK_OVERFLOW_CHECK
+         _KTaskOsAssignStackCheck(new_task);
+#endif
+        SYS_KDEBUG_LOG(KDBG_SCHED, ("switch in interrupt\n"));
+
+
+        HwInterruptcontextSwitch( (x_ubase)&runningtask->stack_point,
+                        (x_ubase)&new_task->stack_point, new_task, context);
+    }
+}
+void KTaskOsAssignAfterIrq(void *context)
+{
+    x_base lock = 0;                                 
+    lock = DISABLE_INTERRUPT();                  
+    HwLockSpinlock(&AssignSpinLock);
+    KTaskOsAssignDoIrqSwitch(context);
+    HwUnlockSpinlock(&AssignSpinLock);           
+    ENABLE_INTERRUPT(lock);
+}
+
+static void UncombineInsert(struct TaskDescriptor *task)
+{
+    uint32 cpu_mask = 0;
+
+    NULL_PARAM_CHECK(task);
+
+#if KTASK_PRIORITY_MAX > 32
+    MERGE_FLAG(&Assign.os_assign_read_vector.ready_vector[task->task_dync_sched_member.bitmap_offset], task->task_dync_sched_member.bitmap_row);
+#endif
+    MERGE_FLAG(&Assign.os_assign_read_vector.priority_ready_group, task->task_dync_sched_member.bitmap_column);
+    AssignPolicyInsert(task, &Assign.os_assign_read_vector);
+    cpu_mask = CPU_MASK ^ (1 << GetCpuId());
+    HwSendIpi(ASSIGN_IPI, cpu_mask);
+}
+
+static void ComnbineInsert(struct TaskDescriptor *task, int coreid)
+{
+    NULL_PARAM_CHECK(task);
+
+#if KTASK_PRIORITY_MAX > 32
+    MERGE_FLAG(&Assign.smp_os_assign_ready_rector[coreid].ready_vector[task->task_dync_sched_member.bitmap_offset], task->task_dync_sched_member.bitmap_row);
+#endif
+    MERGE_FLAG(&Assign.smp_os_assign_ready_rector[coreid].priority_ready_group, task->task_dync_sched_member.bitmap_column);
+    AssignPolicyInsert(task, &Assign.smp_os_assign_ready_rector[coreid]);
+    if (coreid != task->task_smp_info.combined_coreid)
+    {
+        uint32 cpu_mask;
+        cpu_mask = 1 << task->task_smp_info.combined_coreid;
+        HwSendIpi(ASSIGN_IPI, cpu_mask);
+    }
+}
+
+/*
+ * insert a ready task to system ready table with READY state and remove it from suspend list
+ *
+ * @param task the task descriptor
+ *
+ */
+void KTaskInsertToReadyVector(struct TaskDescriptor *task)
+{
+    int coreid = 0;
+
+	NULL_PARAM_CHECK(task);
+
+    KTaskStatSetAsReady(task);
+
+    coreid = task->task_smp_info.combined_coreid;
+
+    switch (coreid)
+    {
+    case UNCOMBINE_CPU_CORE:
+        UncombineInsert(task);
+        break;
+    
+    default:
+        ComnbineInsert(task, coreid);
+        break;
+    }
+
+    SYS_KDEBUG_LOG(KDBG_SCHED, ("insert task[%.*s], the priority: %d\n",
+                                      NAME_NUM_MAX, task->task_base_info.name, task->task_dync_sched_member.cur_prio));
+
+}
+
+static void UncombineRemove(struct TaskDescriptor *task)
+{
+    register x_ubase number = 0;
+    register x_ubase highest_priority = 0;
+
+    NULL_PARAM_CHECK(task);
+
+    if (IsDoubleLinkListEmpty(&(Assign.os_assign_read_vector.priority_ready_vector[task->task_dync_sched_member.cur_prio]))) {
+#if KTASK_PRIORITY_MAX > 32
+        
+        CLEAR_FLAG(&Assign.os_assign_read_vector.ready_vector[task->task_dync_sched_member.bitmap_offset], task->task_dync_sched_member.bitmap_row);
+        if (Assign.os_assign_read_vector.ready_vector[task->task_dync_sched_member.bitmap_offset] == 0) {
+            CLEAR_FLAG(&Assign.os_assign_read_vector.priority_ready_group, task->task_dync_sched_member.bitmap_column);
+        }
+        number = PrioCaculate(Assign.os_assign_read_vector.priority_ready_group);
+        highest_priority = (number * 8) + PrioCaculate(Assign.os_assign_read_vector.ready_vector[number]);
+#else
+        
+        
+        CLEAR_FLAG(&Assign.os_assign_read_vector.priority_ready_group, task->task_dync_sched_member.bitmap_column);   
+        highest_priority = PrioCaculate(Assign.os_assign_read_vector.priority_ready_group);
+#endif
+        Assign.os_assign_read_vector.highest_prio = highest_priority;  
+    }
+}
+
+static void CombineRemove(struct TaskDescriptor *task)
+{
+    register x_ubase number = 0;
+    register x_ubase highest_prio_on_core = 0;
+    uint8 combined_coreid = task->task_smp_info.combined_coreid;
+
+    NULL_PARAM_CHECK(task);
+
+    if (IsDoubleLinkListEmpty(&(Assign.smp_os_assign_ready_rector[combined_coreid].priority_ready_vector[task->task_dync_sched_member.cur_prio]))) {
+#if KTASK_PRIORITY_MAX > 32
+        CLEAR_FLAG(&Assign.smp_os_assign_ready_rector[combined_coreid].ready_vector[task->task_dync_sched_member.bitmap_offset], task->task_dync_sched_member.bitmap_row);
+        if (Assign.os_assign_read_vector.ready_vector[task->task_dync_sched_member.bitmap_offset] == 0) {
+            CLEAR_FLAG(&Assign.smp_os_assign_ready_rector[combined_coreid].priority_ready_group, task->task_dync_sched_member.bitmap_column);
+        }
+        number = PrioCaculate(Assign.smp_os_assign_ready_rector[combined_coreid].priority_ready_group);
+        highest_prio_on_core = (number * 8) + PrioCaculate(Assign.smp_os_assign_ready_rector[combined_coreid].ready_vector[number]);
+#else
+        CLEAR_FLAG(&Assign.smp_os_assign_ready_rector[combined_coreid].priority_ready_group, task->task_dync_sched_member.bitmap_column);
+        highest_prio_on_core = PrioCaculate(Assign.smp_os_assign_ready_rector[combined_coreid].priority_ready_group);
+#endif
+        Assign.smp_os_assign_ready_rector[combined_coreid].highest_prio = highest_prio_on_core;
+    }
+}
+
+/*
+ * a task will be removed from ready table.
+ *
+ * @param task  task descriptor
+ *
+ */
+void KTaskOsAssignRemoveKTask(struct TaskDescriptor *task)
+{
+    
+	NULL_PARAM_CHECK(task);
+
+    SYS_KDEBUG_LOG(KDBG_SCHED, ("remove task[%.*s], the priority: %d\n",
+                                      NAME_NUM_MAX, task->task_base_info.name,
+                                      task->task_dync_sched_member.cur_prio));
+
+    DoubleLinkListRmNode(&(task->task_dync_sched_member.sched_link));
+    switch (task->task_smp_info.combined_coreid)
+    {
+    case UNCOMBINE_CPU_CORE:
+        UncombineRemove(task);
+        break;
+    
+    default:
+        CombineRemove(task);
+        break;
+    }
+}
+
+x_err_t YieldOsAssign(void)
+{
+    x_base lock = 0;
+    int coreid = 0;
+    x_ubase highest_prio = 0;
+    struct TaskDescriptor *new_task = NONE;
+    struct TaskDescriptor *runningtask = NONE;
+    
+    lock  = DISABLE_INTERRUPT();
+    HwLockSpinlock(&AssignSpinLock);
+    coreid = GetCpuId();
+    runningtask = Assign.smp_os_running_task[coreid];
+
+    if (isrManager.done->getCounter()) {
+        HwUnlockSpinlock(&AssignSpinLock);
+        ENABLE_INTERRUPT(lock);
+        return -ERROR;
+    }
+
+    if(Assign.assign_lock[coreid] >= 1) {
+        HwUnlockSpinlock(&AssignSpinLock);
+        ENABLE_INTERRUPT(lock);
+        return -ERROR;
+    }
+    /* if the bitmap is empty then do not switch */
+    if((RET_TRUE == JudgeAssignReadyBitmapIsEmpty(&Assign.os_assign_read_vector)) &&
+        (RET_TRUE == JudgeAssignReadyBitmapIsEmpty(&Assign.smp_os_assign_ready_rector[coreid]))) {
+        HwUnlockSpinlock(&AssignSpinLock);
+        ENABLE_INTERRUPT(lock);
+        return -ERROR;
+    }
+
+    highest_prio = Assign.smp_assign_done->GetHighest();
+    new_task = Assign.smp_assign_done->select();
+
+    if(RET_TRUE != JudgeKTaskStatIsRunning(runningtask)) {
+        CHECK(NONE != new_task);
+    } else {
+        Assign.ready_vector_done->insert(runningtask);
+    }
+
+    new_task->task_smp_info.runing_coreid = coreid;
+    Assign.current_priority[coreid] = (uint8)highest_prio;
+
+    HOOK(hook.assign.hook_Assign,(runningtask, new_task));
+
+    SYS_KDEBUG_LOG(KDBG_SCHED,
+            ("[%d]switch to priority#%d "
+                "task:%.*s(sp:0x%08x), "
+                "from task:%.*s(sp: 0x%08x)\n",
+                isrManager.done->getCounter(), highest_prio,
+                NAME_NUM_MAX, new_task->task_base_info.name, new_task->stack_point,
+                NAME_NUM_MAX, runningtask->task_base_info.name, runningtask->stack_point));
+
+    Assign.smp_assign_done->SwitchToNew(runningtask,new_task);
+
+    ENABLE_INTERRUPT(lock);
+
+    return EOK;
+}
+
+/**
+ * 
+ * OsAssign startup function
+ * .
+ */
+void StartupOsAssign(void)
+{
+    struct TaskDescriptor *FirstRunningTask = NONE;
+
+    FirstRunningTask = Assign.smp_assign_done->select();
+    Assign.smp_assign_done->SetSystemTask(FirstRunningTask);
+    Assign.smp_assign_done->SwitchToFirst(FirstRunningTask);
+}
+
+/**
+ *
+ * system OsAssign init function
+ */
+void SysInitOsAssign(void)
+{
+    SYS_KDEBUG_LOG(KDBG_SCHED, ("start Os Assign: max priority 0x%02x\n",
+                                      KTASK_PRIORITY_MAX));
+
+    Assign.ready_vector_done = &ready_vector_done;
+    Assign.smp_assign_done = &smp_assign_done;
+    Assign.ready_vector_done->init(&Assign.os_assign_read_vector);
+    Assign.smp_assign_done->SmpInit();
+
+}