typedef struct xLIST
{
	listFIRST_LIST_INTEGRITY_CHECK_VALUE			//用来检查列表的完整性
	configLIST_VOLATILE UBaseType_t uxNumberOfItems;//记录列表中列表项的数量
	ListItem_t * configLIST_VOLATILE pxIndex;		//记录最新的列表项，用于遍历列表
	MiniListItem_t xListEnd;						//标记列表的最后一项
	listSECOND_LIST_INTEGRITY_CHECK_VALUE			//用来检查列表的完整性
} List_t;

struct xLIST_ITEM
{
	listFIRST_LIST_ITEM_INTEGRITY_CHECK_VALUE
	configLIST_VOLATILE TickType_t xItemValue;			//序号，用来对列表项进行排列
	struct xLIST_ITEM * configLIST_VOLATILE pxNext;		//指向下一个列表项
	struct xLIST_ITEM * configLIST_VOLATILE pxPrevious;	//指向前一个列表项
	void * pvOwner;										//指向实际包含有该列表项的对象
	void * configLIST_VOLATILE pvContainer;				//指向此列表项归属的列表
	listSECOND_LIST_ITEM_INTEGRITY_CHECK_VALUE
};
typedef struct xLIST_ITEM ListItem_t;

struct xMINI_LIST_ITEM
{
	listFIRST_LIST_ITEM_INTEGRITY_CHECK_VALUE
	configLIST_VOLATILE TickType_t xItemValue;
	struct xLIST_ITEM * configLIST_VOLATILE pxNext;
	struct xLIST_ITEM * configLIST_VOLATILE pxPrevious;
};
typedef struct xMINI_LIST_ITEM MiniListItem_t;

void vTaskStartScheduler( void )
{
	BaseType_t xReturn;
	BaseType_t i;

	//给每个内核都创建一个空闲任务，优先级设为最低（0），任务名为“IDLE”
	for ( i=0; i<portNUM_PROCESSORS; i++) {
		#if ( INCLUDE_xTaskGetIdleTaskHandle == 1 )
		{
			xReturn = xTaskCreatePinnedToCore( prvIdleTask, "IDLE", tskIDLE_STACK_SIZE, ( void * ) NULL, ( tskIDLE_PRIORITY | portPRIVILEGE_BIT ), &xIdleTaskHandle[i], i ); 
		}
		#else
		{
			xReturn = xTaskCreatePinnedToCore( prvIdleTask, "IDLE", tskIDLE_STACK_SIZE, ( void * ) NULL, ( tskIDLE_PRIORITY | portPRIVILEGE_BIT ), NULL, i);
		}
		#endif /* INCLUDE_xTaskGetIdleTaskHandle */	/* Event lists are always in priority order. */
	}
	//创建软件定时器任务，任务名为“Tmr Svc”，此任务只在内核0上运行
	#if ( configUSE_TIMERS == 1 )
	{
		if( xReturn == pdPASS )
		{
			xReturn = xTimerCreateTimerTask();
		}
		else
		{
			mtCOVERAGE_TEST_MARKER();
		}
	}
	#endif /* configUSE_TIMERS */
	if( xReturn == pdPASS )
	{
        //在开启调度器之前不允许被中断打扰，在这里将中断关闭。之前创建的任务堆栈中包含有一个状态字，指示这中断是打开状态，所以当第一个任务运行起来后，中断将会再一次被开启。
		portDISABLE_INTERRUPTS();
		xTickCount = ( TickType_t ) 0U;
		//如果需要使用时间统计功能，下面的这个宏需要用户自定义（配置一个计数器或定时器）
		portCONFIGURE_TIMER_FOR_RUN_TIME_STATS();
		xSchedulerRunning = pdTRUE;//表示调度器开始运行

		//初始化相关硬件：滴答定时器等，这需要用户自行实现
		if( xPortStartScheduler() != pdFALSE )
		{
			//一旦调度器起来后就永远不会执行到这里
		}
		else
		{
			//只有调用了xTaskEndScheduler函数后才会执行到这里
		}
	}
	else
	{
		//如果创建空闲任务或者定时器任务时内存不够就会执行到这里
		configASSERT( xReturn );
	}
}

BaseType_t xPortStartScheduler( void )
{
	#if XCHAL_CP_NUM > 0
	//初始化任务的协处理器
	_xt_coproc_init();
	#endif
	//初始化滴答计数器的分频系数
	_xt_tick_divisor_init();
	//配置、使能滴答计数器
	_frxt_tick_timer_init();
	port_xSchedulerRunning[xPortGetCoreID()] = 1;
    //_frxt_dispatch函数不能直接用C语言调用。调度最高优先级的任务
	__asm__ volatile ("call0    _frxt_dispatch\n");
	//永远不会返回
	return pdTRUE;
}

//在某个具体的核上创建任务
BaseType_t xTaskCreatePinnedToCore(	TaskFunction_t pxTaskCode,
							const char * const pcName,
							const uint32_t usStackDepth,
							void * const pvParameters,
							UBaseType_t uxPriority,
							TaskHandle_t * const pxCreatedTask,
                            const BaseType_t xCoreID )
{
    TCB_t *pxNewTCB;
    BaseType_t xReturn;

    //如果任务栈向上生长，那么先开辟任务控制块TCB的内存，再开辟任务栈的内存，任务栈的地址保存在TCB中
    #if( portSTACK_GROWTH > 0 )
    {
        pxNewTCB = ( TCB_t * ) pvPortMallocTcbMem( sizeof( TCB_t ) );
        if( pxNewTCB != NULL )
        {
            pxNewTCB->pxStack = ( StackType_t * ) pvPortMallocStackMem( ( ( ( size_t ) usStackDepth ) * sizeof( StackType_t ) ) ); 
            if( pxNewTCB->pxStack == NULL )
            {
                vPortFree( pxNewTCB );
                pxNewTCB = NULL;
            }
        }
    }
    #else
    //如果任务栈向下生长，那么先开辟任务栈的内存，再开辟任务控制块TCB的内存，任务栈的地址保存在TCB中
    {
        StackType_t *pxStack;
        pxStack = ( StackType_t * ) pvPortMallocStackMem( ( ( ( size_t ) usStackDepth ) * sizeof( StackType_t ) ) );
        if( pxStack != NULL )
        {
            pxNewTCB = ( TCB_t * ) pvPortMallocTcbMem( sizeof( TCB_t ) ); 
            if( pxNewTCB != NULL )
            {
                pxNewTCB->pxStack = pxStack;
            }
            else
            {
                vPortFree( pxStack );
            }
        }
        else
        {
            pxNewTCB = NULL;
        }
    }
    #endif /* portSTACK_GROWTH */
    if( pxNewTCB != NULL )
    {
        #if( tskSTATIC_AND_DYNAMIC_ALLOCATION_POSSIBLE != 0 )
        {
            //标记该任务后期不需要的时候需要删除
            pxNewTCB->ucStaticallyAllocated = tskDYNAMICALLY_ALLOCATED_STACK_AND_TCB;
        }
        #endif /* configSUPPORT_STATIC_ALLOCATION */
		//初始化任务
        prvInitialiseNewTask( pxTaskCode, pcName, usStackDepth, pvParameters, uxPriority, pxCreatedTask, pxNewTCB, NULL, xCoreID );
        //将新创建的任务加入就绪列表中
        prvAddNewTaskToReadyList( pxNewTCB, pxTaskCode, xCoreID );
        xReturn = pdPASS;
    }
    else
    {
        xReturn = errCOULD_NOT_ALLOCATE_REQUIRED_MEMORY;
    }
    return xReturn;
}

static void prvInitialiseNewTask( 	TaskFunction_t pxTaskCode,
									const char * const pcName,
									const uint32_t ulStackDepth,
									void * const pvParameters,
									UBaseType_t uxPriority,
									TaskHandle_t * const pxCreatedTask,
									TCB_t *pxNewTCB,
									const MemoryRegion_t * const xRegions, const BaseType_t xCoreID )
{
StackType_t *pxTopOfStack;
UBaseType_t x;

	#if( portUSING_MPU_WRAPPERS == 1 )
		//任务使用特权模式创建任务
		BaseType_t xRunPrivileged;
		if( ( uxPriority & portPRIVILEGE_BIT ) != 0U )
		{
			xRunPrivileged = pdTRUE;
		}
		else
		{
			xRunPrivileged = pdFALSE;
		}
		uxPriority &= ~portPRIVILEGE_BIT;
	#endif /* portUSING_MPU_WRAPPERS == 1 */
	#if( ( configCHECK_FOR_STACK_OVERFLOW > 1 ) || ( configUSE_TRACE_FACILITY == 1 ) || ( INCLUDE_uxTaskGetStackHighWaterMark == 1 ) )
	{
		//将任务栈初始化相同的值(0xA5)
		( void ) memset( pxNewTCB->pxStack, ( int ) tskSTACK_FILL_BYTE, ( size_t ) ulStackDepth * sizeof( StackType_t ) );
	}
	#endif
	//根据栈的不同生长方向来计算栈顶位置
	#if( portSTACK_GROWTH < 0 )
	{
		pxTopOfStack = pxNewTCB->pxStack + ( ulStackDepth - ( uint32_t ) 1 );
		pxTopOfStack = ( StackType_t * ) ( ( ( portPOINTER_SIZE_TYPE ) pxTopOfStack ) & ( ~( ( portPOINTER_SIZE_TYPE ) portBYTE_ALIGNMENT_MASK ) ) ); 

		//检查堆栈栈顶地址是否字节对齐
		configASSERT( ( ( ( portPOINTER_SIZE_TYPE ) pxTopOfStack & ( portPOINTER_SIZE_TYPE ) portBYTE_ALIGNMENT_MASK ) == 0UL ) );
		#if ( configENABLE_TASK_SNAPSHOT == 1 )
		{
			pxNewTCB->pxEndOfStack = pxTopOfStack;
		}
#endif
	}
	#else /* portSTACK_GROWTH */
	{
		pxTopOfStack = pxNewTCB->pxStack;
		configASSERT( ( ( ( portPOINTER_SIZE_TYPE ) pxNewTCB->pxStack & ( portPOINTER_SIZE_TYPE ) portBYTE_ALIGNMENT_MASK ) == 0UL ) );
		pxNewTCB->pxEndOfStack = pxNewTCB->pxStack + ( ulStackDepth - ( uint32_t ) 1 );
	}
	#endif /* portSTACK_GROWTH */
	//保存任务的任务名
	for( x = ( UBaseType_t ) 0; x < ( UBaseType_t ) configMAX_TASK_NAME_LEN; x++ )
	{
		pxNewTCB->pcTaskName[ x ] = pcName[ x ];
		if( pcName[ x ] == 0x00 )
		{
			break;
		}
		else
		{
			mtCOVERAGE_TEST_MARKER();
		}
	}
	//任务名太长需要截断
	pxNewTCB->pcTaskName[ configMAX_TASK_NAME_LEN - 1 ] = '\0';
	//修正不合法的优先级
	if( uxPriority >= ( UBaseType_t ) configMAX_PRIORITIES )
	{
		uxPriority = ( UBaseType_t ) configMAX_PRIORITIES - ( UBaseType_t ) 1U;
	}
	else
	{
		mtCOVERAGE_TEST_MARKER();
	}
	pxNewTCB->uxPriority = uxPriority;//初始化任务控制块的优先级字段
	pxNewTCB->xCoreID = xCoreID;//初始化任务所在的内核ID号
	#if ( configUSE_MUTEXES == 1 )
	{
		pxNewTCB->uxBasePriority = uxPriority;//如果使用了互斥信号量，就需要指定基础优先级
		pxNewTCB->uxMutexesHeld = 0;
	}
	#endif /* configUSE_MUTEXES */

	vListInitialiseItem( &( pxNewTCB->xGenericListItem ) );//初始化通用列表项
	vListInitialiseItem( &( pxNewTCB->xEventListItem ) );//初始化事件列表项
	listSET_LIST_ITEM_OWNER( &( pxNewTCB->xGenericListItem ), pxNewTCB );//设置列表项归属
	listSET_LIST_ITEM_VALUE( &( pxNewTCB->xEventListItem ), ( TickType_t ) configMAX_PRIORITIES - ( TickType_t ) uxPriority );//设置事件列表项的值使得优先级从小到大排列
	listSET_LIST_ITEM_OWNER( &( pxNewTCB->xEventListItem ), pxNewTCB );//设置列表项归属
	#if ( portCRITICAL_NESTING_IN_TCB == 1 )
	{
		pxNewTCB->uxCriticalNesting = ( UBaseType_t ) 0U;
	}
	#endif /* portCRITICAL_NESTING_IN_TCB */
	#if ( configUSE_APPLICATION_TASK_TAG == 1 )
	{
		pxNewTCB->pxTaskTag = NULL;
	}
	#endif /* configUSE_APPLICATION_TASK_TAG */
	#if ( configGENERATE_RUN_TIME_STATS == 1 )
	{
		pxNewTCB->ulRunTimeCounter = 0UL;
	}
	#endif /* configGENERATE_RUN_TIME_STATS */
	#if ( portUSING_MPU_WRAPPERS == 1 )
	{
		vPortStoreTaskMPUSettings( &( pxNewTCB->xMPUSettings ), xRegions, pxNewTCB->pxStack, ulStackDepth );
	}
	#else
	{
		/* Avoid compiler warning about unreferenced parameter. */
		( void ) xRegions;
	}
	#endif
	#if( configNUM_THREAD_LOCAL_STORAGE_POINTERS != 0 )
	{
		for( x = 0; x < ( UBaseType_t ) configNUM_THREAD_LOCAL_STORAGE_POINTERS; x++ )
		{
			pxNewTCB->pvThreadLocalStoragePointers[ x ] = NULL;
			#if ( configTHREAD_LOCAL_STORAGE_DELETE_CALLBACKS == 1)
			pxNewTCB->pvThreadLocalStoragePointersDelCallback[ x ] = NULL;
			#endif
		}
	}
	#endif
	#if ( configUSE_TASK_NOTIFICATIONS == 1 )
	{
		pxNewTCB->ulNotifiedValue = 0;
		pxNewTCB->eNotifyState = eNotWaitingNotification;
	}
	#endif
	#if ( configUSE_NEWLIB_REENTRANT == 1 )
	{
		/* Initialise this task's Newlib reent structure. */
		esp_reent_init(&pxNewTCB->xNewLib_reent);
	}
	#endif
	#if( INCLUDE_xTaskAbortDelay == 1 )
	{
		pxNewTCB->ucDelayAborted = pdFALSE;
	}
	#endif
	#if( portUSING_MPU_WRAPPERS == 1 )
	{
		pxNewTCB->pxTopOfStack = pxPortInitialiseStack( pxTopOfStack, pxTaskCode, pvParameters, xRunPrivileged );
	}
	#else /* portUSING_MPU_WRAPPERS */
	{
		pxNewTCB->pxTopOfStack = pxPortInitialiseStack( pxTopOfStack, pxTaskCode, pvParameters );//初始化任务堆栈
	}
	#endif /* portUSING_MPU_WRAPPERS */

	if( ( void * ) pxCreatedTask != NULL )
	{
		//任务句柄其实就是任务控制块的地址
		*pxCreatedTask = ( TaskHandle_t ) pxNewTCB;
	}
	else
	{
		mtCOVERAGE_TEST_MARKER();
	}
}

StackType_t *pxPortInitialiseStack( StackType_t *pxTopOfStack, TaskFunction_t pxCode, void *pvParameters )
{
	StackType_t *sp, *tp;
	XtExcFrame  *frame;
	#if XCHAL_CP_NUM > 0
	uint32_t *p;
	#endif
	uint32_t *threadptr;
	void *task_thread_local_start;
	extern int _thread_local_start, _thread_local_end, _rodata_start;
	// TODO: check that TLS area fits the stack
	uint32_t thread_local_sz = (uint8_t *)&_thread_local_end - (uint8_t *)&_thread_local_start;

	thread_local_sz = ALIGNUP(0x10, thread_local_sz);
	/* 初始化任务堆栈，使之从高地址开始往下依次是：

	----LOW ADDRESSES ----------------------------------------HIGH ADDRESSES----------
	task stack | interrupt stack frame | thread local vars | co-processor save area |
	----------------------------------------------------------------------------------
	           |																	|
			   SP 								                            pxTopOfStack
	*/
	sp = (StackType_t *) (((UBaseType_t)(pxTopOfStack + 1) - XT_CP_SIZE - thread_local_sz - XT_STK_FRMSZ) & ~0xf);//16字节对齐
	for (tp = sp; tp <= pxTopOfStack; ++tp)//将sp到TopOfStack之间的内存清零
		*tp = 0;
	frame = (XtExcFrame *) sp;

	/* 对一些必要的寄存赋值 */
	frame->pc   = (UBaseType_t) pxCode;             //PC指针初始化为任务函数的入口地址
	frame->a0   = 0;                                //组织GDB回溯
	frame->a1   = (UBaseType_t) sp + XT_STK_FRMSZ;  
	frame->exit = (UBaseType_t) _xt_user_exit;      

	/* Set initial PS to int level 0, EXCM disabled ('rfe' will enable), user mode. */
	/* Also set entry point argument parameter. */
	#ifdef __XTENSA_CALL0_ABI__
	frame->a2 = (UBaseType_t) pvParameters;
	frame->ps = PS_UM | PS_EXCM;
	#else
	/* + for windowed ABI also set WOE and CALLINC (pretend task was 'call4'd). */
	frame->a6 = (UBaseType_t) pvParameters;
	frame->ps = PS_UM | PS_EXCM | PS_WOE | PS_CALLINC(1);
	#endif

	#ifdef XT_USE_SWPRI
	/* Set the initial virtual priority mask value to all 1's. */
	frame->vpri = 0xFFFFFFFF;
	#endif

	/* Init threadptr reg and TLS vars */
	task_thread_local_start = (void *)(((uint32_t)pxTopOfStack - XT_CP_SIZE - thread_local_sz) & ~0xf);
	memcpy(task_thread_local_start, &_thread_local_start, thread_local_sz);
	threadptr = (uint32_t *)(sp + XT_STK_EXTRA);
	/* shift threadptr by the offset of _thread_local_start from DROM start;
	   need to take into account extra 16 bytes offset */
	*threadptr = (uint32_t)task_thread_local_start - ((uint32_t)&_thread_local_start - (uint32_t)&_rodata_start) - 0x10;

	#if XCHAL_CP_NUM > 0
	/* Init the coprocessor save area (see xtensa_context.h) */
	p = (uint32_t *)(((uint32_t) pxTopOfStack - XT_CP_SIZE) & ~0xf);
	p[0] = 0;
	p[1] = 0;
	p[2] = (((uint32_t) p) + 12 + XCHAL_TOTAL_SA_ALIGN - 1) & -XCHAL_TOTAL_SA_ALIGN;
	#endif

	return sp;
}

static void prvAddNewTaskToReadyList( TCB_t *pxNewTCB, TaskFunction_t pxTaskCode, BaseType_t xCoreID )
{
	TCB_t *curTCB, *tcb0, *tcb1;
	configASSERT( xCoreID == tskNO_AFFINITY || xCoreID < portNUM_PROCESSORS);
    //确保列表在被更新的过程中不会被中断打断
	taskENTER_CRITICAL(&xTaskQueueMutex);
	{
		uxCurrentNumberOfTasks++;//全局变量，统计任务数量
		//判断这个任务在哪个内核上运行
		if ( xCoreID == tskNO_AFFINITY )
		{
			if ( portNUM_PROCESSORS == 1 )
			{
				xCoreID = 0;
			}
			else
			{
				tcb0 = pxCurrentTCB[0];
				tcb1 = pxCurrentTCB[1];
				if ( tcb0 == NULL )
				{
					xCoreID = 0;
				}
				else if ( tcb1 == NULL )
				{
					xCoreID = 1;
				}
				else if ( tcb0->uxPriority < pxNewTCB->uxPriority && tcb0->uxPriority < tcb1->uxPriority )
				{
					xCoreID = 0;
				}
				else if ( tcb1->uxPriority < pxNewTCB->uxPriority )
				{
					xCoreID = 1;
				}
				else//两个核上的运行的任务，其优先级都比新的任务要高
				{
					xCoreID = xPortGetCoreID();
				}
			}
		}

        //当前的核上没有任务正在运行
		if( pxCurrentTCB[ xCoreID ] == NULL )
		{
			pxCurrentTCB[ xCoreID ] = pxNewTCB;
			if( uxCurrentNumberOfTasks == ( UBaseType_t ) 1 )
			{
#if portFIRST_TASK_HOOK
				if ( xPortGetCoreID() == 0 ) {
					vPortFirstTaskHook(pxTaskCode);
				}
#endif /* configFIRST_TASK_HOOK */
				//正在创建的任务是第一个任务，那么需要先初始化相应的列表
				prvInitialiseTaskLists();
			}
			else
			{
				mtCOVERAGE_TEST_MARKER();
			}
		}
		else
		{
			if( xSchedulerRunning == pdFALSE )
			{
				//新任务的优先级比正在运行的任务优先级高
				if ( pxCurrentTCB[xCoreID] == NULL || pxCurrentTCB[xCoreID]->uxPriority <= pxNewTCB->uxPriority )
				{
					pxCurrentTCB[xCoreID] = pxNewTCB;
				}
			}
			else
			{
				mtCOVERAGE_TEST_MARKER();
			}
		}
		uxTaskNumber++;//uxTaskNumber加1，用作任务控制块编号

		#if ( configUSE_TRACE_FACILITY == 1 )
		{
			pxNewTCB->uxTCBNumber = uxTaskNumber;
		}
		#endif /* configUSE_TRACE_FACILITY */
		traceTASK_CREATE( pxNewTCB );

		prvAddTaskToReadyList( pxNewTCB );

		portSETUP_TCB( pxNewTCB );
	}
	taskEXIT_CRITICAL(&xTaskQueueMutex);
	if( xSchedulerRunning != pdFALSE )
	{
		taskENTER_CRITICAL(&xTaskQueueMutex);
		curTCB = pxCurrentTCB[ xCoreID ];
        //如果新任务的任务优先级最高，而且调度器已经开始正常运行了，那么就执行任务切换
		if( curTCB == NULL || curTCB->uxPriority < pxNewTCB->uxPriority )
		{
			if( xCoreID == xPortGetCoreID() )
			{
				taskYIELD_IF_USING_PREEMPTION();
			}
			else {
				taskYIELD_OTHER_CORE(xCoreID, pxNewTCB->uxPriority);
			}
		}
		else
		{
			mtCOVERAGE_TEST_MARKER();
		}
		taskEXIT_CRITICAL(&xTaskQueueMutex);
	}
	else
	{
		mtCOVERAGE_TEST_MARKER();
	}
}

#define prvAddTaskToReadyList( pxTCB )												\
	traceMOVED_TASK_TO_READY_STATE( pxTCB );										\
	taskRECORD_READY_PRIORITY( ( pxTCB )->uxPriority );								\
	vListInsertEnd( &( pxReadyTasksLists[ ( pxTCB )->uxPriority ] ), &( ( pxTCB )->xGenericListItem ) )//将任务添加到就绪列表的末尾

void vTaskDelete( TaskHandle_t xTaskToDelete )
{
    TCB_t *pxTCB;
    int core = xPortGetCoreID();
    UBaseType_t free_now;

    taskENTER_CRITICAL(&xTaskQueueMutex);
    {
        pxTCB = prvGetTCBFromHandle( xTaskToDelete );//根据任务句柄获取TCB指针
        //将任务从就绪列表中删除
        if( uxListRemove( &( pxTCB->xGenericListItem ) ) == ( UBaseType_t ) 0 )
        {
            taskRESET_READY_PRIORITY( pxTCB->uxPriority );
        }
        else
        {
            mtCOVERAGE_TEST_MARKER();
        }
        //判断该任务是否在等待某个事件，如果是这样，则这个任务会被放到相应的列表中，这里需要将其移除
        if( listLIST_ITEM_CONTAINER( &( pxTCB->xEventListItem ) ) != NULL )
        {
            ( void ) uxListRemove( &( pxTCB->xEventListItem ) );
        }
        else
        {
            mtCOVERAGE_TEST_MARKER();
        }

        //触发调试器刷新任务列表
        uxTaskNumber++;

        //被删除的任务是正在运行的任务，或者在别的核，那么就交给空闲任务来释放内存
        if( pxTCB == pxCurrentTCB[ core ] ||
           (portNUM_PROCESSORS > 1 && pxTCB == pxCurrentTCB[ !core ]) ||
           (portNUM_PROCESSORS > 1 && pxTCB->xCoreID == (!core)) )
        {
            vListInsertEnd( &xTasksWaitingTermination, &( pxTCB->xGenericListItem ) );
            ++uxTasksDeleted;
            portPRE_TASK_DELETE_HOOK( pxTCB, &xYieldPending[xPortGetCoreID()] );//调用任务删除钩子函数
            free_now = pdFALSE;		//不能立即释放内存
        }
        else//要删除的任务不是当前运行的，也不在别的核上
        {
            --uxCurrentNumberOfTasks;
            //重新计算一下还要多长时间执行下一个任务，也就是下一个任务的解锁时间，防止有的任务的解锁时间参考了刚刚被删除的那个任务
            prvResetNextTaskUnblockTime();
            free_now = pdTRUE;
        }
        traceTASK_DELETE( pxTCB );
    }
    taskEXIT_CRITICAL(&xTaskQueueMutex);

    if(free_now == pdTRUE){
        #if ( configNUM_THREAD_LOCAL_STORAGE_POINTERS > 0 ) && ( configTHREAD_LOCAL_STORAGE_DELETE_CALLBACKS )
        prvDeleteTLS( pxTCB );	//Run deletion callbacks before deleting TCB
        #endif
        prvDeleteTCB( pxTCB );	//Must only be called after del cb
    }

    //如果删除的是正在运行的任务，那么删除完以后肯定需要强制进行一次任务切换
    if( xSchedulerRunning != pdFALSE )
    {
        if( pxTCB == pxCurrentTCB[ core ] )
        {
            configASSERT( uxSchedulerSuspended[ core ] == 0 );
            portPRE_TASK_DELETE_HOOK( pxTCB, &xYieldPending[xPortGetCoreID()] );
            portYIELD_WITHIN_API();
        }
        else if ( portNUM_PROCESSORS > 1 && pxTCB == pxCurrentTCB[ !core] )
        {
            //如果被删除的任务正在另外一个核上运行，强制另外一个核做任务切换
            vPortYieldOtherCore( !core );
        }
        else
        {
            mtCOVERAGE_TEST_MARKER();
        }
    }
}

void vTaskSuspend( TaskHandle_t xTaskToSuspend )
{
    TCB_t *pxTCB;
    TCB_t *curTCB;

    taskENTER_CRITICAL(&xTaskQueueMutex);
    {
        pxTCB = prvGetTCBFromHandle( xTaskToSuspend );
        traceTASK_SUSPEND( pxTCB );
        //将任务从就绪列表中删除
        if( uxListRemove( &( pxTCB->xGenericListItem ) ) == ( UBaseType_t ) 0 )
        {
            taskRESET_READY_PRIORITY( pxTCB->uxPriority );
        }
        else
        {
            mtCOVERAGE_TEST_MARKER();
        }

        //将任务从事件列表中删除
        if( listLIST_ITEM_CONTAINER( &( pxTCB->xEventListItem ) ) != NULL )
        {
            ( void ) uxListRemove( &( pxTCB->xEventListItem ) );
        }
        else
        {
            mtCOVERAGE_TEST_MARKER();
        }
        traceMOVED_TASK_TO_SUSPENDED_LIST(pxTCB);
        //将任务添加到挂起列表的最后
        vListInsertEnd( &xSuspendedTaskList, &( pxTCB->xGenericListItem ) );
        curTCB = pxCurrentTCB[ xPortGetCoreID() ];
    }
    taskEXIT_CRITICAL(&xTaskQueueMutex);

    if( pxTCB == curTCB )
    {
        if( xSchedulerRunning != pdFALSE )
        {
            //确保当前核的任务调度器工作正常
            configASSERT( uxSchedulerSuspended[ xPortGetCoreID() ] == 0 );
            portYIELD_WITHIN_API();
        }
        else//任务调度器不在工作，只能手动查找下一个要运行的任务
        {
            //所有的任务都被挂起，事实上这种情况几乎不存在，除非在空闲任务中调用了阻塞的API
            if( listCURRENT_LIST_LENGTH( &xSuspendedTaskList ) == uxCurrentNumberOfTasks )
            {
                taskENTER_CRITICAL(&xTaskQueueMutex);
                pxCurrentTCB[ xPortGetCoreID() ] = NULL;
                taskEXIT_CRITICAL(&xTaskQueueMutex);
            }
            else
            {
                //获取下一个要运行的任务
                vTaskSwitchContext();
            }
        }
    }
    else
    {
        if( xSchedulerRunning != pdFALSE )
        {
            //如果被挂起的任务当前不在运行，重新计算一下还要多长时间执行下一个任务，防止有的任务的解锁时间参考了刚刚被挂起的任务
            taskENTER_CRITICAL(&xTaskQueueMutex);
            {
                prvResetNextTaskUnblockTime();
            }
            taskEXIT_CRITICAL(&xTaskQueueMutex);
        }
        else
        {
            mtCOVERAGE_TEST_MARKER();
        }
    }
}

void vTaskResume( TaskHandle_t xTaskToResume )
{
    TCB_t * const pxTCB = ( TCB_t * ) xTaskToResume;

    configASSERT( xTaskToResume );
    taskENTER_CRITICAL(&xTaskQueueMutex);
    //xTaskToResume不能为NULL，也不应该存在恢复当前正在运行的任务这种情况
    if( ( pxTCB != NULL ) && ( pxTCB != pxCurrentTCB[ xPortGetCoreID() ] ) )
    {
        {
            if( prvTaskIsTaskSuspended( pxTCB ) == pdTRUE )
            {
                traceTASK_RESUME( pxTCB );
                //将要恢复的任务从挂起列表中删除
                ( void ) uxListRemove(  &( pxTCB->xGenericListItem ) );
                //将要恢复的任务添加到就绪任务列表中
                prvAddTaskToReadyList( pxTCB );
                //如果被恢复的任务优先级更高
                if( tskCAN_RUN_HERE(pxTCB->xCoreID) && pxTCB->uxPriority >= pxCurrentTCB[ xPortGetCoreID() ]->uxPriority )
                {
                    //这个yield不会让恢复的任务立即运行，但是会刷新就绪列表
                    taskYIELD_IF_USING_PREEMPTION();
                }
                else if( pxTCB->xCoreID != xPortGetCoreID() )
                {
                    //被恢复的任务不属于当前的核
                    taskYIELD_OTHER_CORE( pxTCB->xCoreID, pxTCB->uxPriority );
                }
                else
                {
                    mtCOVERAGE_TEST_MARKER();
                }
            }
            else
            {
                mtCOVERAGE_TEST_MARKER();
            }
        }
    }
    else
    {
        mtCOVERAGE_TEST_MARKER();
    }
    taskEXIT_CRITICAL(&xTaskQueueMutex);
}

#define taskYIELD()					portYIELD()
#define portYIELD()					vPortYield()

//函数void vPortYield(void)使用汇编实现，主要功能是保存待暂停任务的最小现场环境，清除CPENABLE，最后调用_frxt_dispatch函数实现真正的上下文切换
    .globl  vPortYield
    .type   vPortYield,@function
    .align  4
vPortYield:

    #ifdef __XTENSA_CALL0_ABI__
    addi    sp,  sp, -XT_SOL_FRMSZ
    #else
    entry   sp,  XT_SOL_FRMSZ
    #endif

    rsr     a2,  PS
    s32i    a0,  sp, XT_SOL_PC
    s32i    a2,  sp, XT_SOL_PS
    #ifdef __XTENSA_CALL0_ABI__
    s32i    a12, sp, XT_SOL_A12         /* save callee-saved registers      */
    s32i    a13, sp, XT_SOL_A13
    s32i    a14, sp, XT_SOL_A14
    s32i    a15, sp, XT_SOL_A15
    #else
    /* Spill register windows. Calling xthal_window_spill() causes extra    */
    /* spills and reloads, so we will set things up to call the _nw version */
    /* instead to save cycles.                                              */
    movi    a6,  ~(PS_WOE_MASK|PS_INTLEVEL_MASK)  /* spills a4-a7 if needed */
    and     a2,  a2, a6                           /* clear WOE, INTLEVEL    */
    addi    a2,  a2, XCHAL_EXCM_LEVEL             /* set INTLEVEL           */
    wsr     a2,  PS
    rsync
    call0   xthal_window_spill_nw
    l32i    a2,  sp, XT_SOL_PS                    /* restore PS             */
    wsr     a2,  PS
    #endif

    rsil    a2,  XCHAL_EXCM_LEVEL       /* disable low/med interrupts       */

    #if XCHAL_CP_NUM > 0
    /* Save coprocessor callee-saved state (if any). At this point CPENABLE */
    /* should still reflect which CPs were in use (enabled).                */
    call0   _xt_coproc_savecs
    #endif

    movi    a2,  pxCurrentTCB
	getcoreid a3
	addx4	a2,  a3, a2
    l32i    a2,  a2, 0                  /* a2 = pxCurrentTCB                */
    movi    a3,  0
    s32i    a3,  sp, XT_SOL_EXIT        /* 0 to flag as solicited frame     */
    s32i    sp,  a2, TOPOFSTACK_OFFS    /* pxCurrentTCB->pxTopOfStack = SP  */

    #if XCHAL_CP_NUM > 0
    /* Clear CPENABLE, also in task's co-processor state save area. */
    l32i    a2,  a2, CP_TOPOFSTACK_OFFS /* a2 = pxCurrentTCB->cp_state      */
    movi    a3,  0
    wsr     a3,  CPENABLE
    beqz    a2,  1f
    s16i    a3,  a2, XT_CPENABLE        /* clear saved cpenable             */
1:
    #endif

    /* Tail-call dispatcher. */
    call0   _frxt_dispatch
    /* Never reaches here. */

//该函数的功能是将上下文切换到最高优先级的就绪任务，恢复它的状态，最后将将控制权转交给它
    .globl  _frxt_dispatch
    .type   _frxt_dispatch,@function
    .align  4
_frxt_dispatch:

    #ifdef __XTENSA_CALL0_ABI__
    call0   vTaskSwitchContext  // Get next TCB to resume
    movi    a2, pxCurrentTCB
	getcoreid a3
	addx4	a2,  a3, a2
    #else
    call4   vTaskSwitchContext  // Get next TCB to resume
    movi    a2, pxCurrentTCB
	getcoreid a3
	addx4	a2,  a3, a2
    #endif
    l32i    a3,  a2, 0
    l32i    sp,  a3, TOPOFSTACK_OFFS     /* SP = next_TCB->pxTopOfStack;  */
    s32i    a3,  a2, 0

    /* Determine the type of stack frame. */
    l32i    a2,  sp, XT_STK_EXIT        /* exit dispatcher or solicited flag */
    bnez    a2,  .L_frxt_dispatch_stk

.L_frxt_dispatch_sol:

    /* Solicited stack frame. Restore minimal context and return from vPortYield(). */
    l32i    a3,  sp, XT_SOL_PS
    #ifdef __XTENSA_CALL0_ABI__
    l32i    a12, sp, XT_SOL_A12
    l32i    a13, sp, XT_SOL_A13
    l32i    a14, sp, XT_SOL_A14
    l32i    a15, sp, XT_SOL_A15
    #endif
    l32i    a0,  sp, XT_SOL_PC
    #if XCHAL_CP_NUM > 0
    /* Ensure wsr.CPENABLE is complete (should be, it was cleared on entry). */
    rsync
    #endif
    /* As soons as PS is restored, interrupts can happen. No need to sync PS. */
    wsr     a3,  PS
    #ifdef __XTENSA_CALL0_ABI__
    addi    sp,  sp, XT_SOL_FRMSZ
    ret
    #else
    retw
    #endif

.L_frxt_dispatch_stk:

    #if XCHAL_CP_NUM > 0
    /* Restore CPENABLE from task's co-processor save area. */
    movi    a3, pxCurrentTCB            /* cp_state =                       */
	getcoreid a2
	addx4	a3,  a2, a3
    l32i    a3, a3, 0
    l32i    a2, a3, CP_TOPOFSTACK_OFFS     /* StackType_t                       *pxStack; */
    l16ui   a3, a2, XT_CPENABLE         /* CPENABLE = cp_state->cpenable;   */
    wsr     a3, CPENABLE
    #endif

    /* Interrupt stack frame. Restore full context and return to exit dispatcher. */
    call0   _xt_context_restore

    /* In Call0 ABI, restore callee-saved regs (A12, A13 already restored). */
    #ifdef __XTENSA_CALL0_ABI__
    l32i    a14, sp, XT_STK_A14
    l32i    a15, sp, XT_STK_A15
    #endif

    #if XCHAL_CP_NUM > 0
    /* Ensure wsr.CPENABLE has completed. */
    rsync
    #endif

    /*
    Must return via the exit dispatcher corresponding to the entrypoint from which
    this was called. Interruptee's A0, A1, PS, PC are restored and the interrupt
    stack frame is deallocated in the exit dispatcher.
    */
    l32i    a0, sp, XT_STK_EXIT
    ret

//理论上，该函数只有在滴答定时器中断和crosscore中断中被调用
void vTaskSwitchContext( void )
{
	int irqstate=portENTER_CRITICAL_NESTED();
	tskTCB * pxTCB;
	if( uxSchedulerSuspended[ xPortGetCoreID() ] != ( UBaseType_t ) pdFALSE )
	{
		/* The scheduler is currently suspended - do not allow a context
		switch. */
		xYieldPending[ xPortGetCoreID() ] = pdTRUE;
	}
	else
	{
		xYieldPending[ xPortGetCoreID() ] = pdFALSE;
        xSwitchingContext[ xPortGetCoreID() ] = pdTRUE;
		traceTASK_SWITCHED_OUT();

		#if ( configGENERATE_RUN_TIME_STATS == 1 )
		{
				#ifdef portALT_GET_RUN_TIME_COUNTER_VALUE
					portALT_GET_RUN_TIME_COUNTER_VALUE( ulTotalRunTime );
				#else
					ulTotalRunTime = portGET_RUN_TIME_COUNTER_VALUE();
				#endif

				/* Add the amount of time the task has been running to the
				accumulated time so far.  The time the task started running was
				stored in ulTaskSwitchedInTime.  Note that there is no overflow
				protection here so count values are only valid until the timer
				overflows.  The guard against negative values is to protect
				against suspect run time stat counter implementations - which
				are provided by the application, not the kernel. */
				taskENTER_CRITICAL_ISR(&xTaskQueueMutex);
				if( ulTotalRunTime > ulTaskSwitchedInTime[ xPortGetCoreID() ] )
				{
					pxCurrentTCB[ xPortGetCoreID() ]->ulRunTimeCounter += ( ulTotalRunTime - ulTaskSwitchedInTime[ xPortGetCoreID() ] );
				}
				else
				{
					mtCOVERAGE_TEST_MARKER();
				}
				taskEXIT_CRITICAL_ISR(&xTaskQueueMutex);
				ulTaskSwitchedInTime[ xPortGetCoreID() ] = ulTotalRunTime;
		}
		#endif /* configGENERATE_RUN_TIME_STATS */

		/* Check for stack overflow, if configured. */
		taskFIRST_CHECK_FOR_STACK_OVERFLOW();
		taskSECOND_CHECK_FOR_STACK_OVERFLOW();

		/* Select a new task to run */

		/*
		 We cannot do taskENTER_CRITICAL_ISR(&xTaskQueueMutex); here because it saves the interrupt context to the task tcb, and we're
		 swapping that out here. Instead, we're going to do the work here ourselves. Because interrupts are already disabled, we only
		 need to acquire the mutex.
		*/
#ifdef CONFIG_FREERTOS_PORTMUX_DEBUG
		vPortCPUAcquireMutex( &xTaskQueueMutex, __FUNCTION__, __LINE__ );
#else
		vPortCPUAcquireMutex( &xTaskQueueMutex );
#endif

		unsigned portBASE_TYPE foundNonExecutingWaiter = pdFALSE, ableToSchedule = pdFALSE, resetListHead;
		portBASE_TYPE uxDynamicTopReady = uxTopReadyPriority;
		unsigned portBASE_TYPE holdTop=pdFALSE;

		/*
		 *  ToDo: This scheduler doesn't correctly implement the round-robin scheduling as done in the single-core
		 *  FreeRTOS stack when multiple tasks have the same priority and are all ready; it just keeps grabbing the
		 *  first one. ToDo: fix this.
		 *  (Is this still true? if any, there's the issue with one core skipping over the processes for the other
		 *  core, potentially not giving the skipped-over processes any time.)
		 */

		while ( ableToSchedule == pdFALSE && uxDynamicTopReady >= 0 )
		{
			resetListHead = pdFALSE;
			// Nothing to do for empty lists
			if (!listLIST_IS_EMPTY( &( pxReadyTasksLists[ uxDynamicTopReady ] ) )) {

				ableToSchedule = pdFALSE;
				tskTCB * pxRefTCB;

				/* Remember the current list item so that we
				can detect if all items have been inspected.
				Once this happens, we move on to a lower
				priority list (assuming nothing is suitable
				for scheduling). Note: This can return NULL if
				the list index is at the listItem */
				pxRefTCB = pxReadyTasksLists[ uxDynamicTopReady ].pxIndex->pvOwner;

				if ((void*)pxReadyTasksLists[ uxDynamicTopReady ].pxIndex==(void*)&pxReadyTasksLists[ uxDynamicTopReady ].xListEnd) {
					//pxIndex points to the list end marker. Skip that and just get the next item.
					listGET_OWNER_OF_NEXT_ENTRY( pxRefTCB, &( pxReadyTasksLists[ uxDynamicTopReady ] ) );
				}

				do {
					listGET_OWNER_OF_NEXT_ENTRY( pxTCB, &( pxReadyTasksLists[ uxDynamicTopReady ] ) );
					/* Find out if the next task in the list is
					already being executed by another core */
					foundNonExecutingWaiter = pdTRUE;
					portBASE_TYPE i = 0;
					for ( i=0; i<portNUM_PROCESSORS; i++ ) {
						if (i == xPortGetCoreID()) {
							continue;
						} else if (pxCurrentTCB[i] == pxTCB) {
							holdTop=pdTRUE; //keep this as the top prio, for the other CPU
							foundNonExecutingWaiter = pdFALSE;
							break;
						}
					}

					if (foundNonExecutingWaiter == pdTRUE) {
						/* If the task is not being executed
						by another core and its affinity is
						compatible with the current one,
						prepare it to be swapped in */
						if (pxTCB->xCoreID == tskNO_AFFINITY) {
							pxCurrentTCB[xPortGetCoreID()] = pxTCB;
							ableToSchedule = pdTRUE;
						} else if (pxTCB->xCoreID == xPortGetCoreID()) {
							pxCurrentTCB[xPortGetCoreID()] = pxTCB;
							ableToSchedule = pdTRUE;
						} else {
							ableToSchedule = pdFALSE;
							holdTop=pdTRUE; //keep this as the top prio, for the other CPU
						}
					} else {
						ableToSchedule = pdFALSE;
					}

					if (ableToSchedule == pdFALSE) {
						resetListHead = pdTRUE;
					} else if ((ableToSchedule == pdTRUE) && (resetListHead == pdTRUE)) {
						tskTCB * pxResetTCB;
						do {
							listGET_OWNER_OF_NEXT_ENTRY( pxResetTCB, &( pxReadyTasksLists[ uxDynamicTopReady ] ) );
						} while(pxResetTCB != pxRefTCB);
					}
				} while ((ableToSchedule == pdFALSE) && (pxTCB != pxRefTCB));
			} else {
				if (!holdTop) --uxTopReadyPriority;
			}
			--uxDynamicTopReady;
		}

		traceTASK_SWITCHED_IN();
        xSwitchingContext[ xPortGetCoreID() ] = pdFALSE;

		//Exit critical region manually as well: release the mux now, interrupts will be re-enabled when we
		//exit the function.
#ifdef CONFIG_FREERTOS_PORTMUX_DEBUG
		vPortCPUReleaseMutex( &xTaskQueueMutex, __FUNCTION__, __LINE__ );
#else
		vPortCPUReleaseMutex( &xTaskQueueMutex );
#endif

#if CONFIG_FREERTOS_WATCHPOINT_END_OF_STACK
		vPortSetStackWatchpoint(pxCurrentTCB[xPortGetCoreID()]->pxStack);
#endif

	}
	portEXIT_CRITICAL_NESTED(irqstate);
}

//该函数是系统滴答定时器中断处理函数，每一次tick时钟到来都会调用一次xPortSysTickHandler
    .globl  _frxt_timer_int
    .type   _frxt_timer_int,@function
    .align  4
_frxt_timer_int:

    ENTRY(16)

    #ifdef CONFIG_PM_TRACE
    movi a6, 1 /* = ESP_PM_TRACE_TICK */
    getcoreid a7
    call4 esp_pm_trace_enter
    #endif // CONFIG_PM_TRACE

.L_xt_timer_int_catchup:

    /* Update the timer comparator for the next tick. */
    #ifdef XT_CLOCK_FREQ
    movi    a2, XT_TICK_DIVISOR         /* a2 = comparator increment          */
    #else
    movi    a3, _xt_tick_divisor
    l32i    a2, a3, 0                   /* a2 = comparator increment          */
    #endif
    rsr     a3, XT_CCOMPARE             /* a3 = old comparator value          */
    add     a4, a3, a2                  /* a4 = new comparator value          */
    wsr     a4, XT_CCOMPARE             /* update comp. and clear interrupt   */
    esync

    #ifdef __XTENSA_CALL0_ABI__
    /* Preserve a2 and a3 across C calls. */
    s32i    a2, sp, 4
    s32i    a3, sp, 8
    #endif

    /* Call the FreeRTOS tick handler (see port.c). */
    #ifdef __XTENSA_CALL0_ABI__
    call0   xPortSysTickHandler
    #else
    call4   xPortSysTickHandler
    #endif

    #ifdef __XTENSA_CALL0_ABI__
    /* Restore a2 and a3. */
    l32i    a2, sp, 4
    l32i    a3, sp, 8
    #endif

    /* Check if we need to process more ticks to catch up. */
    esync                               /* ensure comparator update complete  */
    rsr     a4, CCOUNT                  /* a4 = cycle count                   */
    sub     a4, a4, a3                  /* diff = ccount - old comparator     */
    blt     a2, a4, .L_xt_timer_int_catchup  /* repeat while diff > divisor */

#ifdef CONFIG_PM_TRACE
    movi a6, 1 /* = ESP_PM_TRACE_TICK */
    getcoreid a7
    call4 esp_pm_trace_exit
#endif // CONFIG_PM_TRACE

    RET(16)

BaseType_t xPortSysTickHandler( void )
{
	BaseType_t ret;

	portbenchmarkIntLatency();
	traceISR_ENTER(SYSTICK_INTR_ID);
	ret = xTaskIncrementTick();
	if( ret != pdFALSE )
	{
		portYIELD_FROM_ISR();
	} else {
		traceISR_EXIT();
	}
	return ret;
}

#define portYIELD_FROM_ISR()        {traceISR_EXIT_TO_SCHEDULER(); _frxt_setup_switch();}

//在内部设置一个flag，在退出中断的时候_frxt_int_exit会检查该flag，如果发现flag被设置了，就调用函数vPortYieldFromInt
    .global     _frxt_setup_switch
    .type       _frxt_setup_switch,@function
    .align      4
_frxt_setup_switch:

    ENTRY(16)

	getcoreid a3
    movi    a2, port_switch_flag
	addx4	a2,  a3, a2

    movi    a3, 1
    s32i    a3, a2, 0

    RET(16)

    .globl  vPortYieldFromInt
    .type   vPortYieldFromInt,@function
    .align  4
vPortYieldFromInt:
    ENTRY(16)
    #if XCHAL_CP_NUM > 0
    /* Save CPENABLE in task's co-processor save area, and clear CPENABLE.  */
    movi    a3, pxCurrentTCB            /* cp_state =                       */
	getcoreid a2
	addx4	a3,  a2, a3
    l32i    a3, a3, 0

    l32i    a2, a3, CP_TOPOFSTACK_OFFS

    rsr     a3, CPENABLE
    s16i    a3, a2, XT_CPENABLE         /* cp_state->cpenable = CPENABLE;   */
    movi    a3, 0
    wsr     a3, CPENABLE                /* disable all co-processors        */
    #endif

    #ifdef __XTENSA_CALL0_ABI__
    /* Tail-call dispatcher. */
    call0   _frxt_dispatch
    /* Never reaches here. */
    #else
    RET(16)
    #endif

void vTaskDelay( const TickType_t xTicksToDelay )
{
    TickType_t xTimeToWake;
    BaseType_t xAlreadyYielded = pdFALSE;

    //延时的时间如果不大于0，那就相当于直接进行任务切换
    if( xTicksToDelay > ( TickType_t ) 0U )
    {
        configASSERT( uxSchedulerSuspended[ xPortGetCoreID() ] == 0 );
        taskENTER_CRITICAL(&xTaskQueueMutex);
        {
            traceTASK_DELAY();
            //计算唤醒时间
            xTimeToWake = xTickCount + xTicksToDelay;
            //从就绪列表上移除
            if( uxListRemove( &( pxCurrentTCB[ xPortGetCoreID() ]->xGenericListItem ) ) == ( UBaseType_t ) 0 )
            {
                portRESET_READY_PRIORITY( pxCurrentTCB[ xPortGetCoreID() ]->uxPriority, uxTopReadyPriority );
            }
            else
            {
                mtCOVERAGE_TEST_MARKER();
            }
            //添加到延时列表中
            prvAddCurrentTaskToDelayedList( xPortGetCoreID(), xTimeToWake );
        }
        taskEXIT_CRITICAL(&xTaskQueueMutex);
    }
    else
    {
        mtCOVERAGE_TEST_MARKER();
    }
    if( xAlreadyYielded == pdFALSE )
    {
        portYIELD_WITHIN_API();
    }
    else
    {
        mtCOVERAGE_TEST_MARKER();
    }
}

static void prvAddCurrentTaskToDelayedList( const BaseType_t xCoreID, const TickType_t xTimeToWake )
{
	//按照唤醒时间从小到达的顺序，插入延时列表
	listSET_LIST_ITEM_VALUE( &( pxCurrentTCB[ xCoreID ]->xGenericListItem ), xTimeToWake );
	if( xTimeToWake < xTickCount )
	{
        traceMOVED_TASK_TO_OVERFLOW_DELAYED_LIST();
		//唤醒时间已经溢出，将其插入延时溢出列表中
		vListInsert( pxOverflowDelayedTaskList, &( pxCurrentTCB[ xCoreID ]->xGenericListItem ) );
	}
	else
	{
        traceMOVED_TASK_TO_DELAYED_LIST();
		//时间还没有溢出，插入延时列表中
		vListInsert( pxDelayedTaskList, &( pxCurrentTCB[ xCoreID ]->xGenericListItem ) );
		//xNextTaskUnblockTime是一个全局变量，保存着距离下一个要取消阻塞的任务最小时间点值
		if( xTimeToWake < xNextTaskUnblockTime )
		{
			xNextTaskUnblockTime = xTimeToWake;
		}
		else
		{
			mtCOVERAGE_TEST_MARKER();
		}
	}
}

void vTaskDelayUntil( TickType_t * const pxPreviousWakeTime, const TickType_t xTimeIncrement )
{
    TickType_t xTimeToWake;
    BaseType_t xAlreadyYielded=pdFALSE, xShouldDelay = pdFALSE;

    configASSERT( pxPreviousWakeTime );
    configASSERT( ( xTimeIncrement > 0U ) );
    configASSERT( uxSchedulerSuspended[ xPortGetCoreID() ] == 0 );

    taskENTER_CRITICAL(&xTaskQueueMutex);
    {
        const TickType_t xConstTickCount = xTickCount;
        //计算任务被唤醒的时刻
        xTimeToWake = *pxPreviousWakeTime + xTimeIncrement;
        //tick计数器溢出
        if( xConstTickCount < *pxPreviousWakeTime )
        {
            //tick计数器和唤醒时间都溢出，且tick计数器值比唤醒时间小
            if( ( xTimeToWake < *pxPreviousWakeTime ) && ( xTimeToWake > xConstTickCount ) )
            {
                xShouldDelay = pdTRUE;
            }
            else
            {
                mtCOVERAGE_TEST_MARKER();
            }
        }
        else
        {
            //tick计数器没有溢出，唤醒时间溢出或者tick计数器值比唤醒时间小，这两种情况都说明还需要继续延时
            if( ( xTimeToWake < *pxPreviousWakeTime ) || ( xTimeToWake > xConstTickCount ) )
            {
                xShouldDelay = pdTRUE;
            }
            else
            {
                mtCOVERAGE_TEST_MARKER();
            }
        }
        //为本函数的下一次执行做好准备
        *pxPreviousWakeTime = xTimeToWake;
        if( xShouldDelay != pdFALSE )
        {
            traceTASK_DELAY_UNTIL();
            //从就序列表中移除
            if( uxListRemove( &( pxCurrentTCB[ xPortGetCoreID() ]->xGenericListItem ) ) == ( UBaseType_t ) 0 )
            {
                portRESET_READY_PRIORITY( pxCurrentTCB[ xPortGetCoreID() ]->uxPriority, uxTopReadyPriority );
            }
            else
            {
                mtCOVERAGE_TEST_MARKER();
            }
            prvAddCurrentTaskToDelayedList( xPortGetCoreID(), xTimeToWake );
        }
        else
        {
            mtCOVERAGE_TEST_MARKER();
        }
    }
    taskEXIT_CRITICAL(&xTaskQueueMutex);

    if( xAlreadyYielded == pdFALSE )
    {
        portYIELD_WITHIN_API();
    }
    else
    {
        mtCOVERAGE_TEST_MARKER();
    }
}

//上下文切换工作需要等待直到中断被允许后才执行，这里使用cross-core中断来触发自己
#define portYIELD_WITHIN_API() esp_crosscore_int_send_yield(xPortGetCoreID())

typedef struct QueueDefinition
{
	int8_t *pcHead;					//指向队列存储区开始位置
	int8_t *pcTail;					//指向队列存储区最后一个字节
	int8_t *pcWriteTo;				//指向存储区中下一个空闲区域
	union							
	{
		int8_t *pcReadFrom;			//用作队列时指向最后一个出队的队列项首地址
		UBaseType_t uxRecursiveCallCount;//用作递归互斥信号量时用来记录递归互斥信号量被调用的次数
	} u;
	List_t xTasksWaitingToSend;		//那些因为队列满导致入队失败而进入阻塞态的任务就会挂到此列表上，按照优先级排列
	List_t xTasksWaitingToReceive;	//那些因为队列空导致出队失败而进入阻塞态的任务就会挂到此列表上，按照优先级排列

	volatile UBaseType_t uxMessagesWaiting;//队列中当前的消息数量
	UBaseType_t uxLength;			//队列中允许的最大的消息数量
	UBaseType_t uxItemSize;			//每个消息允许的最大长度

	#if( ( configSUPPORT_STATIC_ALLOCATION == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) )
		uint8_t ucStaticallyAllocated;	//如果队列的内存是静态分配的，则为pdTRUE
	#endif

	#if ( configUSE_QUEUE_SETS == 1 )
		struct QueueDefinition *pxQueueSetContainer;
	#endif

    #if ( configUSE_TRACE_FACILITY == 1 )
		UBaseType_t uxQueueNumber;
		uint8_t ucQueueType;
	#endif

	portMUX_TYPE mux;		//因为SMP的原因，所以需要互斥锁

} xQUEUE;
typedef xQUEUE Queue_t;

#define xQueueCreate( uxQueueLength, uxItemSize ) xQueueGenericCreate( ( uxQueueLength ), ( uxItemSize ), ( queueQUEUE_TYPE_BASE ) )//普通消息队列的类型是queueQUEUE_TYPE_BASE
QueueHandle_t xQueueGenericCreate( const UBaseType_t uxQueueLength, const UBaseType_t uxItemSize, const uint8_t ucQueueType )
{
    Queue_t *pxNewQueue;
    size_t xQueueSizeInBytes;
    uint8_t *pucQueueStorage;
    configASSERT( uxQueueLength > ( UBaseType_t ) 0 );
    if( uxItemSize == ( UBaseType_t ) 0 )
    {
        xQueueSizeInBytes = ( size_t ) 0;//如果队列大小为0，那么就不需要存储区
    }
    else
    {
        xQueueSizeInBytes = ( size_t ) ( uxQueueLength * uxItemSize );
    }
    pxNewQueue = ( Queue_t * ) pvPortMalloc( sizeof( Queue_t ) + xQueueSizeInBytes );//分配内存，这里申请的内存大小是队列结构体和队列中消息存储区的总大小
    if( pxNewQueue != NULL )
    {
        pucQueueStorage = ( ( uint8_t * ) pxNewQueue ) + sizeof( Queue_t );
        #if( configSUPPORT_STATIC_ALLOCATION == 1 )
        {
            pxNewQueue->ucStaticallyAllocated = pdFALSE;
        }
        #endif /* configSUPPORT_STATIC_ALLOCATION */
        prvInitialiseNewQueue( uxQueueLength, uxItemSize, pucQueueStorage, ucQueueType, pxNewQueue );//初始化队列
    }
    return pxNewQueue;
}

static void prvInitialiseNewQueue( const UBaseType_t uxQueueLength, const UBaseType_t uxItemSize, uint8_t *pucQueueStorage, const uint8_t ucQueueType, Queue_t *pxNewQueue )
{
	( void ) ucQueueType;
	if( uxItemSize == ( UBaseType_t ) 0 )
	{
        //没有队列存储区，这里将pcHead指向队列开始地址
		pxNewQueue->pcHead = ( int8_t * ) pxNewQueue;
	}
	else
	{
		//设置pcHaed指向队列存储区首地址
		pxNewQueue->pcHead = ( int8_t * ) pucQueueStorage;
	}
	//初始化队列结构体相关成员变量
	pxNewQueue->uxLength = uxQueueLength;
	pxNewQueue->uxItemSize = uxItemSize;
	( void ) xQueueGenericReset( pxNewQueue, pdTRUE );//复位队列
	#if ( configUSE_TRACE_FACILITY == 1 )
	{
		pxNewQueue->ucQueueType = ucQueueType;
	}
	#endif /* configUSE_TRACE_FACILITY */
	#if( configUSE_QUEUE_SETS == 1 )
	{
		pxNewQueue->pxQueueSetContainer = NULL;
	}
	#endif /* configUSE_QUEUE_SETS */
	traceQUEUE_CREATE( pxNewQueue );
}

BaseType_t xQueueGenericReset( QueueHandle_t xQueue, BaseType_t xNewQueue )
{
	Queue_t * const pxQueue = ( Queue_t * ) xQueue;
	configASSERT( pxQueue );

	if ( xNewQueue == pdTRUE )
	{
		vPortCPUInitializeMutex(&pxQueue->mux);//初始化互斥锁
	}
	taskENTER_CRITICAL(&pxQueue->mux);
	{
		pxQueue->pcTail = pxQueue->pcHead + ( pxQueue->uxLength * pxQueue->uxItemSize );//pcTail指向队列存储区的末尾
		pxQueue->uxMessagesWaiting = ( UBaseType_t ) 0U;//队列中当前的消息数量是0
		pxQueue->pcWriteTo = pxQueue->pcHead;//指向队列存储区中下一个可写入的位置
		pxQueue->u.pcReadFrom = pxQueue->pcHead + ( ( pxQueue->uxLength - ( UBaseType_t ) 1U ) * pxQueue->uxItemSize );//指向队列存储区中下一个可读取的位置
		if( xNewQueue == pdFALSE )
		{
			//由于复位队列以后队列依旧是空的，对于那些从队列中读取而被阻塞的任务来说依旧保持阻塞状态。但是对于那些向队列中写入数据而阻塞的任务来说，这些任务需要接触阻塞状态
			if( listLIST_IS_EMPTY( &( pxQueue->xTasksWaitingToSend ) ) == pdFALSE )
			{
				if( xTaskRemoveFromEventList( &( pxQueue->xTasksWaitingToSend ) ) == pdTRUE )
				{
					queueYIELD_IF_USING_PREEMPTION();
				}
				else
				{
					mtCOVERAGE_TEST_MARKER();
				}
			}
			else
			{
				mtCOVERAGE_TEST_MARKER();
			}
		}
		else
		{
			//初始化队列中的列表xTasksWaitingToSend和xTasksWaitingToReceive
			vListInitialise( &( pxQueue->xTasksWaitingToSend ) );
			vListInitialise( &( pxQueue->xTasksWaitingToReceive ) );
		}
	}
	taskEXIT_CRITICAL(&pxQueue->mux);
	return pdPASS;
}