coroutine
一个程序要真正运行起来，需要两个因素：可执行代码段、数据。体现在 CPU 中，主要包含以下几个方面：
- EIP 寄存器：用来存储 CPU 要读取指令的地址
- ESP 寄存器：指向当前线程栈的栈顶位置
- 其他通用寄存器的内容：包括代表函数参数的 rdi、rsi 等等。
- 线程栈中的内存内容。
这些数据内容，我们一般将其称为 “上下文” 或者 “现场”。有栈协程的原理，就是从线程的上下文下手，如果把线程的上下文完全改变，即：改变 EIP 寄存的内容，指向其他指令地址；改变线程栈的内存内容等等。
这样的话，当前线程运行的程序也就完全改变了，是一个全新的程序。
协程的实现分为有栈和无栈的方式，有栈的实现方式又是可以分为“独立栈” 和 "共享栈"的实现方式。
共享栈的实现
仅以云风的coroutine实现为例。它的底层是使用 Linux下的 ucontext 函数簇实现的。
typedef struct ucontext_t {
struct ucontext_t *uc_link; // 要去的环境
sigset_t uc_sigmask; // 屏蔽的信号
stack_t uc_stack; // 当前这个环境要使用的栈内存
mcontext_t uc_mcontext;
...
} ucontext_t;
每次在进行协程切换时，都是由先将当前上下文数据保存共享栈中，当切换回来的时候再从共享栈中恢复数据。设置的共享栈的大小是 1M。调度器的结构如下：
#define STACK_SIZE (1024*1024) // 1M
/// @brief: 协程调度器
struct schedule {
char stack[STACK_SIZE]; // 运行时栈
ucontext_t main; // 主协程的上下文
int nco; // 当前存活的协程个数，用作协程 id
int cap; // 协程管理器的当前最大容量，如果不够了，则进行扩容
int running; // 正在运行的协程ID
struct coroutine** co; // 一个一维数组，用于存放协程
};
/// @brief: 协程
struct coroutine {
coroutine_func func; // 协程运行的函数
void* ud; // func 参数
ucontext_t ctx; // 协程上下文
struct schedule* sch; // 该协程所属的调度器
ptrdiff_t cap; // 已经分配的内存大小
ptrdiff_t size; // 当前协程运行时栈，保存起来后的大小
int status; // 协程当前的状态
char* stack; // 当前协程的保存起来的运行时栈
};
创建协程调度器
函数 coroutine_open 负责创建一个协程调度器，初始化协程调度器的数值。
#define DEFAULT_COROUTINE 16 // 初始化建立协程时大小
/// @brief: 创建一个协程调度器
struct schedule * coroutine_open(void)
{
struct schedule *S = malloc(sizeof(struct schedule)); // 这里做的主要就是分配内存，同时赋初值
S->nco = 0;
S->cap = DEFAULT_COROUTINE;
S->running = -1;
S->co = malloc(sizeof(struct coroutine *) * S->cap);
memset(S->co, 0, sizeof(struct coroutine *) * S->cap);
return S;
}
创建一个协程
函数 _co_new 初始化 coroutine 对象：分配内存以及设置初始化状态是 COROUTINE_READY 。coroutine_new 将 创建的协程与对应的协程调度器联系起来。如果当前的协程数已经超过协程调度器中的协程数最大值cap就会两倍扩容。最终还是会更新协程调度器的相关参数，返回协程的 id。
/// @brief: 创建协程
/// @param: @c S 是协程调度器
/// @param: @c func 协程运行函数
/// @param: @c ud 是函数 func 的参数
/// @param: co 新创建的对象
struct coroutine*
_co_new(struct schedule* S , coroutine_func func, void *ud) {
struct coroutine* co = malloc(sizeof(struct coroutine));
co->func = func;
co->ud = ud;
co->sch = S;
co->cap = 0;
co->size = 0;
co->status = COROUTINE_READY; // 默认的最初状态都是 COROUTINE_READY
co->stack = NULL;
return co;
}
/// @brief: 创建一个协程对象
/// @param: S 该协程所属的调度器
/// @param: func 该协程函数执行体
/// @param: ud func 的参数
/// @return: 新建的协程的 ID
int
coroutine_new(struct schedule* S, coroutine_func func, void *ud) {
struct coroutine *co = _co_new(S, func , ud);
// 如果目前协程的数量已经大于调度器的容量，那么进行扩容
if (S->nco >= S->cap)
{
int id = S->cap; // 新的协程的id直接为当前容量的大小
S->co = realloc(S->co, S->cap * 2 * sizeof(struct coroutine *)); // 2倍扩容
memset(S->co + S->cap , 0 , sizeof(struct coroutine *) * S->cap); // 初始化新的内存
S->co[S->cap] = co; // 将新创建的协程放入调度器中
S->cap *= 2; // 将容量参数更新为两倍
++S->nco; // 协程数更新
return id;
}
else
{
// 如果目前协程的数量小于调度器的容量，则取一个为NULL的位置，放入新的协程
int i;
for (i=0; i<S->cap; i++) {
// 为什么不 i % S->cap, 而是要从 nco+i 开始呢，因为前nco有很大概率都非NULL的，直接跳过去更好
int id = (i + S->nco) % S->cap;
if (S->co[id] == NULL) {
S->co[id] = co;
++S->nco;
return id;
}
}
}
assert(NULL);
return -1;
}
切出
coroutine_resume 函数会切入到指定协程中执行。当前正在执行的协程的上下文会被保存起来，同时上下文替换成新的协程，该协程的状态将被置为 RUNNING。
/// @biref: 切换到对应协程中执行
/// @param: S 协程调度器
/// @param: id 协程ID
void
coroutine_resume(struct schedule * S, int id) {
assert(S->running == -1);
assert(0 <= id && id < S->cap);
struct coroutine* C = S->co[id]; // 取出协程
if (C == NULL) return;
int status = C->status;
switch(status) {
case COROUTINE_READY:
getcontext(&C->ctx); // 初始化 ucontext_t 结构体，将当前的上下文放到 C->ctx 里面
// 将当前协程的运行时栈的栈顶设置为 S->stack
// 每个协程都这么设置，这就是所谓的共享栈。（注意，这里是栈顶）
C->ctx.uc_stack.ss_sp = S->stack;
C->ctx.uc_stack.ss_size = STACK_SIZE;
C->ctx.uc_link = &S->main; // 如果协程执行完，将切换到主协程中执行
S->running = id;
C->status = COROUTINE_RUNNING;
// 设置执行 C->ctx 函数, 并将 S 作为参数传进去
uintptr_t ptr = (uintptr_t)S;
makecontext(&C->ctx, (void (*)(void)) mainfunc, 2, (uint32_t)ptr, (uint32_t)(ptr>>32));
// 将当前的上下文放入S->main中，并将C->ctx的上下文替换到当前上下文
swapcontext(&S->main, &C->ctx);
break;
case COROUTINE_SUSPEND:
// 将协程所保存的栈的内容，拷贝到当前运行时栈中
// 其中C->size在yield时有保存
memcpy(S->stack + STACK_SIZE - C->size, C->stack, C->size);
S->running = id;
C->status = COROUTINE_RUNNING;
swapcontext(&S->main, &C->ctx);
break;
default:
assert(0);
}
}
yield
/// @brief: 将当前正在运行的协程让出，切换到主协程上
/// @param S 协程调度器
void
coroutine_yield(struct schedule * S) {
// 取出当前正在运行的协程
int id = S->running;
assert(id >= 0);
struct coroutine * C = S->co[id];
assert((char *)&C > S->stack);
// 将当前运行的协程的栈内容保存起来
_save_stack(C,S->stack + STACK_SIZE);
// 将当前栈的状态改为 挂起
C->status = COROUTINE_SUSPEND;
S->running = -1;
// 所以这里可以看到，只能从协程切换到主协程中
swapcontext(&C->ctx , &S->main);
}
static void _save_stack(struct coroutine *C, char *top) {
char dummy = 0;
assert(top - &dummy <= STACK_SIZE);
// 如果已分配内存小于当前栈的大小，则释放内存重新分配
if (C->cap < top - &dummy) {
free(C->stack);
C->cap = top-&dummy;
C->stack = malloc(C->cap);
}
C->size = top - &dummy;
// 从 dummy 拷贝 size 内存到 C->stack
memcpy(C->stack, &dummy, C->size);
}
