nucleus学习

task的TCB结构：

typedef struct TC_TCB_STRUCT
{
/* Standard thread information first. This information is used by
the target dependent portion of this component. Changes made
to this area of the structure can have undesirable side effects. */
CS_NODE tc_created; /* Node for linking to */ //链接指向创建task链表
/* created task list */
UNSIGNED tc_id; /* Internal TCB ID */
CHAR tc_name[NU_MAX_NAME]; /* Task name */
DATA_ELEMENT tc_status; /* Task status */
BOOLEAN tc_delayed_suspend; /* Delayed task suspension*/
DATA_ELEMENT tc_priority; /* Task priority */
BOOLEAN tc_preemption; /* Task preemption enable */ //是否抢占
UNSIGNED tc_scheduled; /* Task scheduled count */
UNSIGNED tc_cur_time_slice; /* Current time slice */
VOID *tc_stack_start; /* Stack starting address */ //栈起始地址
VOID *tc_stack_end; /* Stack ending address */
VOID *tc_stack_pointer; /* Task stack pointer */
UNSIGNED tc_stack_size; /* Task stack's size */
UNSIGNED tc_stack_minimum; /* Minimum stack size */
struct TC_PROTECT_STRUCT
*tc_current_protect; /* Current protection */
VOID *tc_saved_stack_ptr; /* Previous stack pointer */
UNSIGNED tc_time_slice; /* Task time slice value */
/* Information after this point is not used in the target dependent
portion of this component. Hence, changes in the following section
should not impact assembly language routines. */
struct TC_TCB_STRUCT
*tc_ready_previous, /* Previously ready TCB */ //指向上一个TCB
*tc_ready_next; /* next and previous ptrs */ //指向下一个TCB
/* Task control information follows. */
UNSIGNED tc_priority_group; /* Priority group mask bit*/
struct TC_TCB_STRUCT
**tc_priority_head; /* Pointer to list head */ //指向TCB链表头
DATA_ELEMENT *tc_sub_priority_ptr; /* Pointer to sub-group */
DATA_ELEMENT tc_sub_priority; /* Mask of sub-group bit */
DATA_ELEMENT tc_saved_status; /* Previous task status */
BOOLEAN tc_signal_active; /* Signal active flag */
#if PAD_3
DATA_ELEMENT tc_padding[PAD_3];
#endif
/* Task entry function */
VOID (*tc_entry)(UNSIGNED, VOID *); //task入口函数，下面是参数
UNSIGNED tc_argc; /* Optional task argument */
VOID *tc_argv; /* Optional task argument */
VOID (*tc_cleanup) (VOID *);/* Clean-up routine */
VOID *tc_cleanup_info; /* Clean-up information */
struct TC_PROTECT_STRUCT
*tc_suspend_protect; /* Protection at time of */
/* task suspension */
/* Task timer information. */ //计时器
INT tc_timer_active; /* Active timer flag */
TM_TCB tc_timer_control; /* Timer control block */
/* Task signal control information. */
UNSIGNED tc_signals; /* Current signals */
UNSIGNED tc_enabled_signals; /* Enabled signals */
/* tc_saved_status and tc_signal_active are now defined above in an
attempt to keep DATA_ELEMENT types together. */
/* Signal handling routine. */ //signal中断处理？
VOID (*tc_signal_handler) (UNSIGNED);
/* Reserved words for the system and a single reserved word for the
application. */
UNSIGNED tc_system_reserved_1; /* System reserved word */
UNSIGNED tc_system_reserved_2; /* System reserved word */
UNSIGNED tc_system_reserved_3; /* System reserved word */
UNSIGNED tc_app_reserved_1; /* Application reserved */
/* This information is accessed in assembly */
#if ((NU_SUPERV_USER_MODE == 1)||(NU_MODULE_SUPPORT == 1))
UNSIGNED tc_su_mode; /* Supervisor/User mode indicator */
UNSIGNED tc_module; /* Module identifier */
#endif
} TC_TCB;

TCC创建任务函数：

STATUS TCC_Create_Task(NU_TASK *task_ptr, CHAR *name,
VOID (*task_entry)(UNSIGNED, VOID *), UNSIGNED argc, VOID *argv,
VOID *stack_address, UNSIGNED stack_size,
OPTION priority, UNSIGNED time_slice,
OPTION preempt, OPTION auto_start)
{
R1 TC_TCB *task; /* Task control block ptr */
R2 INT i; /* Working index variable */
STATUS status = NU_SUCCESS;
NU_SUPERV_USER_VARIABLES
/* Switch to supervisor mode */
NU_SUPERVISOR_MODE();
/* Move input task pointer into internal pointer. */
task = (TC_TCB *) task_ptr;
#ifdef NU_ENABLE_STACK_CHECK
/* Call stack checking function to check for an overflow condition. */
TCT_Check_Stack();
#endif
#ifdef NU_ENABLE_HISTORY
/* Make an entry that corresponds to this function in the system history
log. */
HIC_Make_History_Entry(NU_CREATE_TASK_ID, (UNSIGNED) task,
(UNSIGNED) name, (UNSIGNED) task_entry);
#endif
/* First, clear the task ID just in case it is an old Task
Control Block. */
task -> tc_id = 0;
/* Fill in the task name. */
for (i = 0; i < NU_MAX_NAME; i++)
task -> tc_name[i] = name[i];
/* Fill in the basic task information. */
task -> tc_entry = task_entry;
task -> tc_argc = argc;
task -> tc_argv = argv;
task -> tc_status = NU_PURE_SUSPEND; //这里设定为pure_suspend,完全挂起。如果设定auto_start，调用resume_task()唤醒task
task -> tc_delayed_suspend = NU_FALSE;
task -> tc_scheduled = 0;
task -> tc_time_slice = time_slice;
task -> tc_cur_time_slice = time_slice;
task -> tc_current_protect = NU_NULL;
task -> tc_suspend_protect = NU_NULL;
task -> tc_cleanup = NU_NULL;
task -> tc_cleanup_info = NU_NULL;
/* Setup task's preemption posture. */
if (preempt == NU_PREEMPT)
task -> tc_preemption = NU_TRUE;
else
task -> tc_preemption = NU_FALSE;
/* Fill in information about the task's stack. */
task -> tc_stack_start = stack_address;
task -> tc_stack_end = 0;
task -> tc_stack_size = stack_size;
task -> tc_stack_minimum = stack_size;
/* Setup priority information for the task. There are two bit maps
associated with each task. The first bit map indicates which group
of 8-priorities it is. The second bit map indicates the actual
priority within the group. */
task -> tc_priority = priority;
task -> tc_priority_head = &(TCD_Priority_List[priority]); //这里挂载进TCB双向链表指针
task -> tc_sub_priority = (DATA_ELEMENT) (1 << (priority & 7));
priority = priority >> 3;
task -> tc_priority_group = ((UNSIGNED) 1) << priority;
task -> tc_sub_priority_ptr = &(TCD_Sub_Priority_Groups[priority]);
/* Initialize link pointers. */
task -> tc_created.cs_previous = NU_NULL;
task -> tc_created.cs_next = NU_NULL;
task -> tc_ready_previous = NU_NULL;
task -> tc_ready_next = NU_NULL;
/* Build a stack frame for this task by calling TCT_Build_Task_Stack. */
TCT_Build_Task_Stack(task);
/* Initialize the signal information of the task. */
task -> tc_signals = 0;
task -> tc_enabled_signals = 0;
task -> tc_signal_handler = 0;
task -> tc_signal_active = NU_FALSE;
/* Initialize additional kernel options data */
#if (NU_SUPERV_USER_MODE == 1)
task->tc_su_mode = 0; /* Initially in User mode */
task->tc_module = 0; /* Not initially bound to a module */
#endif
/* Initialize the task timer. */
task -> tc_timer_active = NU_FALSE;
TMC_Init_Task_Timer(&(task -> tc_timer_control), (VOID *) task);
/* Protect the list of created tasks. */
TCT_Protect(&TCD_List_Protect);
/* At this point the task is completely built. The ID can now be
set and it can be linked into the created task list. */
task -> tc_id = TC_TASK_ID;
#if defined(NU_MODULE_SUPPORT) && (NU_MODULE_SUPPORT > 0)
/* If executing in a thread's context, bind to that thread's module */
if(TCD_Current_Thread != NU_NULL)
{
status = MSC_Bind_Module_Task(
(MS_MODULE*)(((TC_TCB*)(TCD_Current_Thread))->tc_module), task);
}
else /* It must be initialization time, so use the current module */
{
status = MSC_Bind_Module_Task(msd_current_module, task);
}
#endif /* NU_MODULE_SUPPORT */
/* Link the task into the list of created tasks and increment the
total number of tasks in the system. */
CSC_Place_On_List(&TCD_Created_Tasks_List, &(task -> tc_created));
TCD_Total_Tasks++;
#ifdef INCLUDE_PROVIEW
_RTProf_DumpTask(task,RT_PROF_CREATE_TASK);
#endif
/* Release the protection. */
TCT_Unprotect();
/* Determine if the task should be automatically started. */
if (auto_start == NU_START)
{
/* Protect the system data structures. */
TCT_Protect(&TCD_System_Protect);
/* Start the task by resuming it. If the preemption is required,
leave the current task. */
if (TCC_Resume_Task(task_ptr, NU_PURE_SUSPEND))
/* Transfer control back to the system. */
TCT_Control_To_System();
else
/* Release the protection. */
TCT_Unprotect();
}
/* Return to user mode */
NU_USER_MODE();
/* Return successful completion. */
return(status);
}

TCC创建HISR函数：

STATUS TCC_Create_HISR(NU_HISR *hisr_ptr, CHAR *name,
VOID (*hisr_entry)(VOID), OPTION priority,
VOID *stack_address, UNSIGNED stack_size)
{
R1 TC_HCB *hisr; /* HISR control block ptr */
R2 INT i; /* Working index variable */
STATUS status = NU_SUCCESS;
NU_SUPERV_USER_VARIABLES
/* Switch to supervisor mode */
NU_SUPERVISOR_MODE();
/* Move input HISR pointer into internal pointer. */
hisr = (TC_HCB *) hisr_ptr;
#ifdef NU_ENABLE_STACK_CHECK
/* Call stack checking function to check for an overflow condition. */
TCT_Check_Stack();
#endif
#ifdef NU_ENABLE_HISTORY
/* Make an entry that corresponds to this function in the system history
log. */
HIC_Make_History_Entry(NU_CREATE_HISR_ID, (UNSIGNED) hisr,
(UNSIGNED) name, (UNSIGNED) hisr_entry);
#endif
/* First, clear the HISR ID just in case it is an old HISR
Control Block. */
hisr -> tc_id = 0;
/* Fill in the HISR name. */
for (i = 0; i < NU_MAX_NAME; i++)
hisr -> tc_name[i] = name[i];
/* Fill in the basic HISR information. */
hisr -> tc_entry = hisr_entry;
hisr -> tc_scheduled = 0;
hisr -> tc_activation_count = 0;
hisr -> tc_cur_time_slice = 0;
/* Fill in information about the HISR's stack. */
hisr -> tc_stack_start = stack_address;
hisr -> tc_stack_end = 0;
hisr -> tc_stack_size = stack_size;
hisr -> tc_stack_minimum = stack_size;
/* Setup priority information for the HISR. Priorities range from 0 to
TC_HISR_PRIORITIES - 1. */
hisr -> tc_priority = priority & 3; //这里优先级与上了3，所以只有0、1、2三种。优先级会更高
/* Initialize link pointers. */
hisr -> tc_created.cs_previous = NU_NULL; //这里不加双向链表
hisr -> tc_created.cs_next = NU_NULL;
hisr -> tc_active_next = NU_NULL;
/* Clear protect pointer. */
hisr -> tc_current_protect = NU_NULL;
/* Initialize additional kernel options data */
#if (NU_SUPERV_USER_MODE == 1)
hisr->tc_su_mode = 1; /* TCT_HISR_Shell in Supervisor mode */
hisr->tc_module = 0; /* Not initially bound to a module */
#endif
/* Build a stack frame for this HISR by calling TCT_Build_HISR_Stack. */
TCT_Build_HISR_Stack(hisr);
/* Protect the list of created HISRs. */
TCT_Protect(&TCD_HISR_Protect);
/* At this point the HISR is completely built. The ID can now be
set and it can be linked into the created HISR list. */
hisr -> tc_id = TC_HISR_ID;
#if defined(NU_MODULE_SUPPORT) && (NU_MODULE_SUPPORT > 0)
/* If executing in a thread's context, bind to that thread's module */
if(TCD_Current_Thread != NU_NULL)
{
status = MSC_Bind_Module_HISR(
(MS_MODULE*)(((TC_TCB*)(TCD_Current_Thread))->tc_module), hisr);
}
else /* It must be initialization time, so use the current module */
{
status = MSC_Bind_Module_HISR(msd_current_module, hisr);
}
#endif /* NU_MODULE_SUPPORT */
/* Link the HISR into the list of created HISRs and increment the
total number of HISRs in the system. */
CSC_Place_On_List(&TCD_Created_HISRs_List, &(hisr -> tc_created)); //在这里加入了链表？
TCD_Total_HISRs++; //增加了链表长度计数
#ifdef INCLUDE_PROVIEW
_RTProf_DumpHisr(hisr,RT_PROF_CREATE_HISR);
#endif
/* Release the protection. */
TCT_Unprotect();
/* Return to user mode */
NU_USER_MODE();
/* Return successful completion. */
return(status);
}

在tct.s中有TCT_Control_To_System，主要要建立新的system_stack:

;************************************************************************
;*
;* FUNCTION
;*
;* TCT_Control_To_System
;*
;* DESCRIPTION
;*
;* This function returns control from a thread to the system. Note
;* that this service is called in a solicited manner, i.e. it is
;* not called from an interrupt thread. Registers required by the
;* compiler to be preserved across function boundaries are saved by
;* this routine. Note that this is usually a sub-set of the total
;* number of available registers.
;*
;* CALLED BY
;*
;* Other Components
;*
;* CALLS
;*
;* TCT_Schedule Schedule the next thread
;*
;* INPUTS
;*
;* None
;*
;* OUTPUTS
;*
;* None
;*
;* HISTORY
;*
;* NAME DATE REMARKS
;*
;* W. Lamie 02-15-1994 Created initial version 1.0
;* D. Lamie 02-15-1994 Verified version 1.0
;* C. Meredith 03-01-1994 Corrected problem in time-slice
;* reset logic, resulting in
;* version 1.1
;* D. Lamie 03-18-1994 Verified version 1.1
;*
;************************************************************************
;VOID TCT_Control_To_System(void)
;{
.def $TCT_Control_To_System
$TCT_Control_To_System ; Dual-state interworking veneer
.state16
BX r15
NOP
.state32
B _TCT_Control_To_System
.def _TCT_Control_To_System
_TCT_Control_To_System
; Lockout interrupts.
MRS r0,CPSR ; Pickup current CPSR //获取CPSR值
ORR r0,r0,#LOCKOUT ; Build interrupt lockout value
MSR CPSR,r0 ; Lockout interrupts //写入CPSR中断屏蔽位
; Save a minimal context of the thread.
STMDB r13!,{r4-r12,r14} ; Save minimal context of thread on //保存上下文
; the current stack
.if THUMB //如果是THUMB模式
MOV r2,r14 ; Determine what state the caller
MOV r2,r2,LSL #31 ; was in and build an
MOV r2,r2,LSR #26 ; appropriate state mask
STR r2,[r13, #-4]! ; Place it on the stack
.endif
MOV r2,#0 ; Build solicited stack type value //建立solicited stack（请求栈？）
; and NU_NULL value
STR r2,[r13, #-4]! ; Place it on the top of the stack //用r2替换r13下面一格的内容，r2不是0吗。那不是删除了r4的内容吗？
; Setup a pointer to the thread control block.
; REG_Thread_Ptr = (TC_TCB *) TCD_Current_Thread;
LDR r1,Current_Thread ; Pickup current thread ptr address //获取当前进程指针地址
LDR r0,[r1, #0] ; Pickup current thread pointer
; Clear the current thread control block pointer.
; TCD_Current_Thread = NU_NULL;
LDR r3,Slice_State ; Pickup time slice state address //获取time Slice_State地址
STR r2,[r1, #0] ; Set current thread pointer to //又把进程指针清零了
; NU_NULL
; Check to see if a time slice is active. If so, copy the original time
; slice into the current time slice field of the task's control block.
; if (TMD_Time_Slice_State == 0)
; {
LDR r1,[r3, #0] ; Pickup time slice state flag //r3是Slice_State中的值到r1
CMP r1,#0 ; Compare with active value //比较是否是0
BNE TCT_No_Stop_TS_1 ; If non-active, don't disable //如果不是0，跳转到TCT_No_Stop_TS_1
; Insure that the next time the task runs it gets a fresh time
; slice.
; REG_Thread_Ptr -> tc_cur_time_slice = REG_Thread_Ptr -> tc_time_slice;
LDR r1,[r0, #40h] ; Pickup original time slice //从另一个地方找了time slice
; Clear any active time slice by setting the state to NOT_ACTIVE.
; TMD_Time_Slice_State = 1;
MOV r2,#1 ; Build disable value //设置了1关闭
STR r2,[r3, #0] ; Disable time slice //设置time_slice_state
STR r1,[r0, #20h] ; Reset current time slice //明明已经禁止了为什么还要赋值current time_slice呢。
; }
TCT_No_Stop_TS_1: //这里是TCT_No_Stop_TS_1
; Save off the current stack pointer in the control block.
; REG_Thread_Ptr -> tc_stack_pointer = (VOID *) REG_Stack_Ptr;
STR r13,[r0, #2ch] ; Save the thread's stack pointer //保存进程栈指针，为什么Slice_State加上#2ch就是进程栈指针呢，可能是结构体向下移动了几位
; Clear the task's current protection.
; (REG_Thread_Ptr -> tc_current_protect) -> tc_tcb_pointer = NU_NULL;
; REG_Thread_Ptr -> tc_current_protect = NU_NULL;
LDR r1,[r0, #38h] ; Pickup current thread pointer //获取当前进程指针
MOV r2,#0 ; Build NU_NULL value //r2置0
STR r2,[r0, #38h] ; Clear the protect pointer field //清除保护指针字段
STR r2,[r1, #0] ; Release the actual protection //释放实际保护
; Switch to the system stack.
; REG_Stack_Ptr = TCD_System_Stack;
LDR r1, System_Stack ; Pickup address of stack pointer //这里应该建立了新的system栈
LDR r2, System_Limit ; Pickup address of stack limit ptr
LDR r13,[r1, #0] ; Switch to system stack
LDR r10,[r2, #0] ; Setup system stack limit
; Finished, return to the scheduling loop.
B _TCT_Schedule ; Return to scheduling loop //跳转到_TCT_Schedule
;}

在tct.s中有TCT_Schedule(void)内容，这里开关的中断屏蔽寄存器，来使得进程能跟切换（进程指针的获取）：

;************************************************************************
;*
;* FUNCTION
;*
;* TCT_Schedule
;*
;* DESCRIPTION
;*
;* This function waits for a thread to become ready. Once a thread
;* is ready, this function initiates a transfer of control to that
;* thread.
;*
;* CALLED BY
;*
;* INC_Initialize Main initialization routine
;*
;* CALLS
;*
;* TCT_Control_To_Thread Transfer control to a thread
;*
;* INPUTS
;*
;* TCD_Execute_Task Pointer to task to execute
;*
;* OUTPUTS
;*
;* None
;*
;* HISTORY
;*
;* NAME DATE REMARKS
;*
;* W. Lamie 02-15-1994 Created initial version 1.0
;* D. Lamie 02-15-1994 Verified version 1.0
;*
;************************************************************************
;VOID TCT_Schedule(void)
;{
.def $TCT_Schedule
$TCT_Schedule ; Dual-state interworking veneer
.state16 //16位模式下？
BX r15
NOP
.state32 //32位模式下
B _TCT_Schedule
.def _TCT_Schedule
_TCT_Schedule //明明下面就是_TCT_Schedule为什么要跳转
; Restore interrupts according to the value contained in //根据在TCD_Interrupt_Level中值恢复中断
; TCD_Interrupt_Level.
LDR r1,Int_Level ; Build address of interrupt level //把Int_Level地址读取到r1
MRS r0,CPSR ; Pickup current CPSR //读取CPSR到r0
LDR r2,[r1, #0] ; Pickup current interrupt lockout //获取当前中断屏蔽字段
BIC r0,r0,#LOCK_MSK ; Clear the interrupt lockout bits //清除中断屏蔽
ORR r0,r0,r2 ; Build new interrupt lockout CPSR //设置新的中断屏蔽字段
MSR CPSR,r0 ; Setup new CPSR //写回CPSR
LDR r2,Execute_HISR ; Pickup TCD_Execute_HISR address //获取TCD_Execute_HISR地址到r2
LDR r3,Execute_Task ; Pickup TCD_Execute_Task address //获取TCD_Execute_Task地址到r3
.if $$isdefed("INCLUDE_PROVIEW")
; Nucleus ProView Hook
; We check if upon entering TCT_Schedule we already have a task to excute. //确认是否进入了TCT_Schedule时已经运行了task
; if not, we start IDLE. //如果没运行就空闲
LDR r0,[r2, #0] ; Pickup highest priority HISR ptr //获取最高有限级的HISR指针
CMP r0,#0 ; Is there a HISR active? //是否已经运行，0是运行
BNE TCT_Schedule_Thread ; Found an HISR //建立一个HISR，下面是TCT_Schedule_Thread
LDR r0,[r3, #0] ; Pickup highest priority Task ptr //获取任务的最高优先级
CMP r0,#0 ; Is there a task active? //判断是否运行
BNE TCT_Schedule_Thread ; If not, start IDLE. //不是0就开始IDLE
STR r2,[r13, #-4]! ; Save r2 on the stack //把r2压入栈Execute_HISR地址
STR r3,[r13, #-4]! ; Save r3 on the stack //把r3压入栈Execute_Task地址
BL __NU_Idle_Hook //跳转到__NU_IDLE_HOOK这个是进等待吧，钩子
LDR r3,[r13], #4 ; Recover r2
LDR r2,[r13], #4 ; Recover r3
.endif
; Wait until a thread (task or HISR) is available to execute.
; do
; {
TCT_Schedule_Loop:
; } while ((!TCD_Execute_HISR) && (!TCD_Execute_Task)); //TCD_Execute_HISR或TCD_Execute_Task为空就一直IDLE
LDR r0,[r2, #0] ; Pickup highest priority HISR ptr
CMP r0,#0 ; Is there a HISR active?
BNE TCT_Schedule_Thread ; Found an HISR
LDR r0,[r3, #0] ; Pickup highest priority Task ptr
CMP r0,#0 ; Is there a task active?
BEQ TCT_Schedule_Loop ; If not, continue the search
; Yes, either a task or an HISR is ready to execute. Lockout
; interrupts while the thread is transferred to.
TCT_Schedule_Thread: //这里应该是调度任务了
MRS r1,CPSR ; Pickup CPSR again //获取CPSR
ORR r1,r1,#LOCKOUT ; Build interrupt lockout value //进行逻辑或设置中断屏蔽值
MSR CPSR,r1 ; Lockout interrupts //为什么设置了中断屏蔽就会运行了，是不是通过开关中断屏蔽，来让任务自动抢占？上面获取了HISR最高优先级的指针地址
; Transfer control to the thread by falling through to the following
; routine.
;}

control_to_thread,只要确认了time slice有没有正常工作。:

;************************************************************************
;*
;* FUNCTION
;*
;* TCT_Control_To_Thread
;*
;* DESCRIPTION
;*
;* This function transfers control to the specified thread. Each
;* time control is transferred to a thread, its scheduled counter
;* is incremented. Additionally, time-slicing for task threads is
;* enabled in this routine. The TCD_Current_Thread pointer is
;* setup by this function.
;*
;* CALLED BY
;*
;* TCT_Schedule Indirectly called
;* TCT_Protect Protection task switch
;*
;* CALLS
;*
;* None
;*
;* INPUTS
;*
;* thread Thread control block pointer
;*
;* OUTPUTS
;*
;* None
;*
;* HISTORY
;*
;* NAME DATE REMARKS
;*
;* W. Lamie 02-15-1994 Created initial version 1.0
;* D. Lamie 02-15-1994 Verified version 1.0
;*
;************************************************************************
;VOID TCT_Control_To_Thread(TC_TCB *thread)
;{
_TCT_Control_To_Thread
; Setup the current thread pointer.
; TCD_Current_Thread = (VOID *) thread; //设置当前进程指针
LDR r1,Current_Thread ; Pickup current thread ptr address
LDR r2,[r0, #1ch] ; Pickup scheduled count
STR r0,[r1, #0] ; Setup current thread pointer
; Increment the thread scheduled counter.
; thread -> tc_scheduled++; //增加scheduled计数
LDR r3,[r0, #20h] ; Pickup time slice value
ADD r2,r2,#1 ; Increment the scheduled count
STR r2,[r0, #1ch] ; Store new scheduled count
; Check for time slice option.
; if (thread -> tc_cur_time_slice) //确认time_slice
; {
CMP r3,#0 ; Is there a time slice?
BEQ TCT_No_Start_TS_1 ; If 0, there is no time slice //如果是0，表明没有。time slice没有运行
; Start a time slice.
; TMD_Time_Slice = thread -> tc_cur_time_slice;
; TMD_Time_Slice_State = 0;
LDR r2,Time_Slice ; Pickup address of TMD_Time_Slice //获取time slice
LDR r1,Slice_State ; Pickup address of //获取time slice state
; TMD_Time_Slice_State
STR r3,[r2, #0] ; Setup the time slice //设置time slice
MOV r2,#0 ; Build active state flag //置0
STR r2,[r1,#0] ; Set the active flag //设置活动标志
; }
TCT_No_Start_TS_1: //这里是TCT_No_Start_TS_1
.if $$isdefed("INCLUDE_PROVIEW") //如果定义了INCLUDE_PROVIEW
; Nucleus ProView Hook
STR r0,[r13, #-4]! ; Save r0 on the stack //把r0压入栈
BL __NU_Schedule_Task_Hook ; Branch to RTView //跳转到__NU_Schedule_Task_Hook
LDR r0,[r13], #4 ; Recover return address
.endif
; Pickup the stack pointer and resume the thread.
; REG_Stack_Ptr = thread -> tc_stack_pointer;
LDR r13,[r0, #2ch] ; Switch to thread //运行新的thread

任务的切换主要是上下文的切换，也就是task栈的切换，函数的调用会保存部分regs和返回地址，这些动作都是编译器来完成的，而OS中的任务切换是运行时（runtime）的一种状态变化，因此编译器也无能为力，所以对于上下文的保存需要代码来实现。

任务的抢占是异步的因此必须要通过中断来实现，一般每次timer的中断决定当前的task的slice time是否expired，然后设置TCT_Set_Execute_Task为相同优先级的其他task或更高优先级的task；高优先级的task抢占低优先级的task，一般是外部中断触发，在HISR中resume_task()唤醒高优先级的task，然后schedule到高优先级的task中，因为timer的HISR是在系统初始化就已经注册的，只是执行timeout和time slice超时后的操作，并没有执行resume_task的动作。

http://blog.chinaunix.net/uid-22003667-id-3291833.html

无欲速，无见小利。欲速，则不达；见小利，则大事不成。