// 一個Task可以看成是一個需要異步執(zhí)行的任務，coroutine的抽象描述
struct Task
{
	char	name[256];
	char	state[256];
    // 前后指針
	Task	*next;
	Task	*prev;
	Task	*allnext;
	Task	*allprev;
    // 執(zhí)行上下文
	Context	context;
    // 睡眠時間
	uvlong	alarmtime;
	uint	id;
    // 協(xié)程棧指針
	uchar	*stk;
    // 協(xié)程棧大小
	uint	stksize;
    // 協(xié)程是否退出了
	int	exiting;
    // 在在alltask的中的索引下標
	int	alltaskslot;
    // 是否是系統(tǒng)協(xié)程
	int	system;
    // 是否在就緒狀態(tài)
	int	ready;
    // Task需要執(zhí)行的函數(shù)
	void	(*startfn)(void*);
    // startfn的參數(shù)
	void	*startarg;
    // 自定義數(shù)據(jù)
	void	*udata;
};

int taskcreate(void (*fn)(void*), void *arg, uint stack)
{
	int id;
	Task *t;
    // 分配task和stack的空間
	t = taskalloc(fn, arg, stack);
	// 協(xié)程的數(shù)量+1
	taskcount++;
	id = t->id;
	if(nalltask%64 == 0){
		alltask = realloc(alltask, (nalltask+64)*sizeof(alltask[0]));
		if(alltask == nil){
			fprint(2, "out of memory\n");
			abort();
		}
	}
    // 記錄位置
	t->alltaskslot = nalltask;
    // 保存到alltask中
	alltask[nalltask++] = t;
    // 修改狀態(tài)為就緒，可以被調(diào)度，并且加入到就緒隊列
	taskready(t);
	return id;
}

/*
 * taskalloc函數(shù)的主要邏輯是申請Task結(jié)構(gòu)體所需的內(nèi)存和執(zhí)行時棧的內(nèi)存，
 * 然后初始化各個字段。在此之后，一個協(xié)程就被創(chuàng)建成功了，接著執(zhí)行taskready
 * 把協(xié)程加入就緒隊列中。
 * */
static Task*
taskalloc(void (*fn)(void*), void *arg, uint stack)
{
	Task *t;
	sigset_t zero;
	uint x, y;
	ulong z;
	/* allocate the task and stack together */
	// 結(jié)構(gòu)體本身的大小和棧大小
	// 協(xié)程棧大小是256*1024
	t = malloc(sizeof *t+stack);
	if(t == nil){
		fprint(2, "taskalloc malloc: %r\n");
		abort();
	}
	memset(t, 0, sizeof *t);
	// 棧的內(nèi)存位置
	t->stk = (uchar*)(t+1);
	// 棧大小
	t->stksize = stack;
	// 協(xié)程id
	t->id = ++taskidgen;
	// 協(xié)程工作函數(shù)和參數(shù)
	t->startfn = fn;
	t->startarg = arg;
	/* do a reasonable initialization */
	memset(&t->context.uc, 0, sizeof t->context.uc);
	sigemptyset(&zero);
	// 初始化uc_sigmask字段為空，即不阻塞信號
	sigprocmask(SIG_BLOCK, &zero, &t->context.uc.uc_sigmask);
	/* must initialize with current context */
	// 初始化uc字段
	if(getcontext(&t->context.uc) < 0){
		fprint(2, "getcontext: %r\n");
		abort();
	}
	/* call makecontext to do the real work. */
	/* leave a few words open on both ends */
	// 設(shè)置協(xié)程執(zhí)行時的棧位置和大小
	t->context.uc.uc_stack.ss_sp = t->stk+8;
	t->context.uc.uc_stack.ss_size = t->stksize-64;
#if defined(__sun__) && !defined(__MAKECONTEXT_V2_SOURCE)		/* sigh */
#warning "doing sun thing"
	/* can avoid this with __MAKECONTEXT_V2_SOURCE but only on SunOS 5.9 */
	t->context.uc.uc_stack.ss_sp = 
		(char*)t->context.uc.uc_stack.ss_sp
		+t->context.uc.uc_stack.ss_size;
#endif
	/*
	 * All this magic is because you have to pass makecontext a
	 * function that takes some number of word-sized variables,
	 * and on 64-bit machines pointers are bigger than words.
	 */
//print("make %p\n", t);
	z = (ulong)t;
	y = z;
	z >>= 16;	/* hide undefined 32-bit shift from 32-bit compilers */
	x = z>>16;
	// 保存信息到uc字段
	makecontext(&t->context.uc, (void(*)())taskstart, 2, y, x);
	return t;
}

/*
 * 修改協(xié)程的狀態(tài)并加入就緒隊列
 * */
void taskready(Task *t)
{
	t->ready = 1;
	addtask(&taskrunqueue, t);
}

	// 將上下文置為零值
	memset(&t->context.uc, 0, sizeof t->context.uc);
	// 將信號集zero清空
	sigemptyset(&zero);
	// 初始化uc_sigmask字段為空，即不阻塞信號
	sigprocmask(SIG_BLOCK, &zero, &t->context.uc.uc_sigmask);
	// 將當前上下文信息保存到t-context.uc結(jié)構(gòu)體中
	if(getcontext(&t->context.uc) < 0){
		fprint(2, "getcontext: %r\n");
		abort();
	}
	// 設(shè)置協(xié)程執(zhí)行時的棧位置和大小
	t->context.uc.uc_stack.ss_sp = t->stk+8;
	t->context.uc.uc_stack.ss_size = t->stksize-64;
	z = (ulong)t;
	y = z;
	z >>= 16;
	x = z>>16;
	// 設(shè)置協(xié)程的工作函數(shù)到上下文信息中
	makecontext(&t->context.uc, (void(*)())taskstart, 2, y, x);

typedef struct ucontext
  {
    unsigned long int uc_flags;
    struct ucontext *uc_link;//后序上下文
    __sigset_t uc_sigmask;// 信號屏蔽字掩碼
    stack_t uc_stack;// 上下文所使用的棧
    // 保存的上下文的寄存器信息
    // 比如pc、sp、bp
    // pc程序計數(shù)器：記錄下一條指令的地址
    // sp堆棧指針：指向函數(shù)調(diào)用棧棧頂?shù)闹羔?，所以新?shù)據(jù)入棧將存入sp+1的地址
    // bp基址指針：指向函數(shù)調(diào)用棧的首地址
    mcontext_t uc_mcontext;
    long int uc_filler[5];
  } ucontext_t;
//其中mcontext_t 定義如下
typedef struct
  {
    gregset_t __ctx(gregs);//所裝載寄存器
    fpregset_t __ctx(fpregs);//寄存器的類型
} mcontext_t;
//其中g(shù)regset_t 定義如下
typedef greg_t gregset_t[NGREG];//包括了所有的寄存器的信息

int getcontext(ucontext_t* ucp)

int setcontext(const ucontext_t *ucp)

void makecontext(ucontext_t *ucp, void (*func)(), int argc, ...)

int swapcontext(ucontext_t *oucp, ucontext_t *ucp)

static void taskscheduler(void)
{
	int i;
	Task *t;
	taskdebug("scheduler enter");
	for(;;){
		// 如果沒有就緒態(tài)協(xié)程了，就退出
		if(taskcount == 0)
			exit(taskexitval);
		// 從就緒隊列中拿出一個協(xié)程
		t = taskrunqueue.head;
		if(t == nil){
			fprint(2, "no runnable tasks! %d tasks stalled\n", taskcount);
			exit(1);
		}
		// 從就緒隊列中刪除這個協(xié)程
		deltask(&taskrunqueue, t);
		 // 將協(xié)程狀態(tài)改為非就緒態(tài)
		t->ready = 0;
		// 保存正在執(zhí)行的協(xié)程
		taskrunning = t;
		// 切換次數(shù)+1
		tasknswitch++;
		taskdebug("run %d (%s)", t->id, t->name);
		// 切換到t執(zhí)行，將當前cpu中的上下文信息保存到taskschedcontext中
        // 然后將t->context中的上下文信息恢復到cpu中執(zhí)行
		contextswitch(&taskschedcontext, &t->context);
		// 執(zhí)行結(jié)束
		taskrunning = nil;
		// 剛才執(zhí)行的協(xié)程t退出了
		if(t->exiting){
			// 如果不是系統(tǒng)協(xié)程，協(xié)程個數(shù)減一
			if(!t->system)
				taskcount--;
			// 保存當前協(xié)程在alltask的索引
			i = t->alltaskslot;
			// 將最后一個協(xié)程切換到當前協(xié)程的位置，因為當前協(xié)程要退出了
			alltask[i] = alltask[--nalltask];
			// 更新被置換協(xié)程的索引
			alltask[i]->alltaskslot = i;
			// 釋放堆內(nèi)存
			free(t);
		}
	}
}

static void contextswitch(Context *from, Context *to)
{
	if(swapcontext(&from->uc, &to->uc) < 0){
		fprint(2, "swapcontext failed: %r\n");
		assert(0);
	}
}

/*
 * 協(xié)程主動讓出CPU
 * 1.將主動讓出的協(xié)程重新加入到就緒隊列
 * 2.將當前協(xié)程的狀態(tài)標記為讓出
 * 3.執(zhí)行協(xié)程切換的邏輯
 * */
int taskyield(void)
{
	int n;
	// 協(xié)程的讓出次數(shù)
	n = tasknswitch;
	// 將當前主動讓出的協(xié)程放進等待隊列
	taskready(taskrunning);
	// 標記當前協(xié)程的狀態(tài)為“讓出”
	taskstate("yield");
	// 切換協(xié)程
	taskswitch();
	// 等于0說明當前只有自己一個協(xié)程，調(diào)度的時候taskswitch加1，所以這里要減1
	return tasknswitch - n - 1;
}

/*
 * 切換協(xié)程
 * */
void taskswitch(void)
{
	needstack(0);
	// 將當前CPU中的上下文信息保存到taskrunning->context結(jié)構(gòu)體中
	// 然后將調(diào)度中心上下文恢復到CPU中執(zhí)行
	contextswitch(&taskrunning->context, &taskschedcontext);
}