协程杂记
协程杂记
协程是什么
协程是一种协作式多任务模型，不同于线程的抢占式多任务模型。协程是由程序员自己控制的，可以在任意时刻挂起或者恢复一个协程，更适合于用来实现彼此熟悉的程序组件。
在通常使用线程的情景中，负责处理不同任务的线程之间存在着数据竞争，使用加锁可以解决问题，但其实并不符合我们的本意。以生产者消费者为例，我们希望消费者可以获取到生产者生产的数据，但是我们并不想要线程带来的额外开销(如加锁解锁)。协程的出现就解决了这个问题，生产者产生数据后，主动挂起，消费者用完数据后，主动切换到生产者。主要的改变就协程实际上变成了串行执行，但是却不会带来额外的开销，本质还是一个用户态的线程(所以想要高效的利用CPU还是要使用线程)，这样两个相互依赖的任务不存在数据竞争，减少了维护同步的开销。
如果非抢占式调度（主动yield），且产生数据竞争的临界区没有跨越一个调度，那么是不需要锁的。因此协程理论上可以不使用锁。
var q := new 队列
coroutine 生产者
loop
while q 不满载
建立某些新产品
向 q 增加这些产品
yield 消费者
coroutine 消费者
loop
while q 不空载
从 q 移除某些产品
使用这些产品
yield 生产者
适用场景
协程适用于IO密集型任务，如网络请求，文件读写等。在这些任务中，CPU的利用率很低，大部分时间都在等待IO操作完成。使用线程的话，会造成大量的线程切换，而协程的切换是用户自己控制的，这种情况下协程的性能会更好。
协程通常有yield和resume两个操作，yield用于挂起当前协程，resume用于恢复一个挂起的协程，从上一个yield的地方继续执行。
偶然看到的特殊实现
循环展开
循环展开作为一种优化手段，通过将循环体内的代码复制多次、减少循环的次数，进而减少分支预测次数，提高程序的性能(详见csapp)。
下面是一个循环展开的例子，展开次数为 8 次。
send(to, from, count)
register short *to, *from;
register count;
{
register n = count % 8;
while (n-- > 0) {
*to = *from++;
}
n = count / 8;
if (n == 0) return;
do {
*to = *from++;
*to = *from++;
*to = *from++;
*to = *from++;
*to = *from++;
*to = *from++;
*to = *from++;
*to = *from++;
} while (--n > 0)
}
达夫设备（Duff's device）是一种循环展开的特殊形式，借助switch的特性实现。
C标准switch的规定：在switch控制语句内，条件标号（case）可以出现在任意子语句之前，充作其前缀(像label一样是Labeled statements)；若未加入break语句，则在switch语句根据条件判定，跳转到对应标号并开始执行后，控制流会无视其余条件标号限定，一直执行到switch嵌套语句的末尾。
因此可以实现一种抽象的循环展开
send(to, from, count)
register short *to, *from;
register count;
{
register n = (count + 7) / 8;
switch (count % 8) {
case 0: do { *to = *from++;
case 7: *to = *from++;
case 6: *to = *from++;
case 5: *to = *from++;
case 4: *to = *from++;
case 3: *to = *from++;
case 2: *to = *from++;
case 1: *to = *from++;
} while (--n > 0);
}
}
为什么要扯到循环展开，达夫设备呢？因为协程的实现中，有一种特殊的实现方式，就是使用达夫设备来实现协程的切换。
无栈协程实现
无栈协程的本质就是一个状态机，同一协程协程的切换本质不过是指令指针寄存器的改变。
有栈无栈并不是指是否有运行时栈，而是指协程之间是否有调用栈来记录栈帧。
int function(void) {
static int i, state = 0;
switch (state) {
case 0: // 函数开始执行
for (i = 0; i < 10; i++) {
state = 1; // 我们会回到 "case 1" 的地方
return i;
case 1:; // 从上一次返回之后的地方开始执行
}
}
使用宏隐藏细节
#define crBegin static int state=0; switch(state) { case 0:
// 使用 do ... while(0) 可以确保当 crReturn 位于 if ... else 之间时，不需要用大括号将其扩起来
#define crReturn(i,x) do { state=i; return x; case i:; } while (0)
#define crFinish }
int function(void) {
static int i;
crBegin;
for (i = 0; i < 10; i++) {
crReturn(1, i);
}
crFinish;
}
在这种规则下，函数主体要用CrBegin和CrFinish包围，多次调用要保持的变量是static。另外，由于case的label属性，crReturn的第一个参数不能不能重复，否则会报错duplicate case value。可以用__LINE__来生成唯一的标号。
#define crReturn(x) do { state=__LINE__; return x; \
case __LINE__:; } while (0)
一个生产者消费者的例子
// 读取用户输入的20个字符，每次读取一行
#include<iostream>
using namespace std;
#define crBegin static int scrLine = 0; switch(scrLine) { case 0:;
#define crReturn(z) \
do {\
scrLine=__LINE__;\
return (z); case __LINE__:;\
} while (0)
#define crReturnV \
do {\
scrLine=__LINE__;\
return; case __LINE__:;\
} while (0)
#define crFinishV }
#define crFinish(z) } return (z)
char* produce(void) {
static int num = 0, numpre = 0;
static char buf[100];
char c;
crBegin;
while(num < 20){
while((c=getchar())!='\n'){
buf[num++]=c;
if(num >= 20){
break;
}
}
buf[num] = 0;
crReturn(buf+numpre);
numpre = num;
}
crFinish(nullptr);
}
int consume(){
char* p = produce();
if(p == nullptr) return -1;
cout << p << endl;
}
int main(){
while(consume()!=-1);
}
没有必要使用协程宏把生产者消费者两段代码都重写了。这里只重写了produce，consume则作为 caller 存在。
以上代码都依赖于static变量，所以不适合多线程重入。
如果要在多线程环境下使用，需要将所有本地变量放在一个上下文结构体中，在需要使用协程的地方先创建ccrContext z = 0，并将地址&z作为参数传递给协程。具体实现见coroutine.h。
#define ccrContParam void **ccrParam
#define ccrBeginContext struct ccrContextTag { int ccrLine
#define ccrEndContext(x) } *x = (struct ccrContextTag *)*ccrParam
#define ccrBegin(x) if(!x) {x= *ccrParam=malloc(sizeof(*x)); x->ccrLine=0;}\
if (x) switch(x->ccrLine) { case 0:;
#define ccrFinish(z) } free(*ccrParam); *ccrParam=0; return (z)
#define ccrFinishV } free(*ccrParam); *ccrParam=0; return
#define ccrReturn(z) \
do {\
((struct ccrContextTag *)*ccrParam)->ccrLine=__LINE__;\
return (z); case __LINE__:;\
} while (0)
#define ccrReturnV \
do {\
((struct ccrContextTag *)*ccrParam)->ccrLine=__LINE__;\
return; case __LINE__:;\
} while (0)
#define ccrStop(z) do{ free(*ccrParam); *ccrParam=0; return (z); }while(0)
#define ccrStopV do{ free(*ccrParam); *ccrParam=0; return; }while(0)
#define ccrContext void *
#define ccrAbort(ctx) do { free (ctx); ctx = 0; } while (0)
int ascending (ccrContParam) {
ccrBeginContext;
int i;
ccrEndContext(foo);
ccrBegin(foo);
for (foo->i=0; foo->i<10; foo->i++) {
ccrReturn(foo->i);
}
ccrFinish(-1);
}
int main(void) {
ccrContext z = 0;
do {
printf("got number %d\n", ascending(&z));
} while (z);
}
参考
Coroutines in C
完整实现coroutine.h
较易懂的实现
仿照xv6的用户态线程实验(将汇编上下文切换改为使用ucontext.h)，实现的对称有栈协程库，协程不共享栈。
在有栈协程中，将每个并行事务看成是一个函数调用，而协程库负责保存让出执行权时的协程的上下文（包括局部变量、返回地址等）
主要提供了create、yield、join、release等接口。主要代码100行左右，个人认为可读性还是比较高的。
- create：创建一个协程，传入函数
- yield：挂起当前协程，对称的，所有协程都可使用
- join：主线程等待所有协程结束(好像也不那么对称了)
- release：释放主线程资源，由创建的协程交替执行
#include <ucontext.h>
#include <functional>
#include <iostream>
#include <memory>
#include <random>
#include <vector>
using namespace std;
void wrapfunc();
typedef std::function<void()> Task;
enum State {
FREE, // 槽位空闲
RUNNABLE, // 等待运行
RUNNING, // 正在运行
};
enum { STACK_SIZE = 4096, MAX_CO = 24 };
struct coroutine {
char stack[STACK_SIZE];
State state;
ucontext_t ctx;
Task task;
bool isDead() { return state == FREE; }
};
coroutine coroutines[MAX_CO];
coroutine *current = nullptr;
size_t cnt = 0;
void init()
{
current = coroutines;
current->state = RUNNING;
}
void schedule()
{
// 在协程表中从当前协程的下一个协程开始找到下一个可运行的协程
coroutine *t, *next = nullptr;
t = current + 1;
for (int i = 0; i < MAX_CO; i++) {
if (t >= coroutines + MAX_CO) {
t = coroutines;
}
if (t->state == RUNNABLE) {
next = t;
break;
}
t++;
}
if (!next) {
return;
}
if (current != next) {
next->state = RUNNING;
t = current;
current = next;
swapcontext(&t->ctx, &next->ctx);
}
}
coroutine *create(Task task)
{
coroutine *t = nullptr;
for (int i = 0; i < MAX_CO; i++) {
if (coroutines[i].state == FREE) {
t = coroutines + i;
break;
}
}
if (!t) {
cout << "no free coroutine" << endl;
exit(1);
}
t->state = RUNNABLE;
t->task = task;
getcontext(&t->ctx);
t->ctx.uc_link = NULL; // 当前上下文结束后返回的上下文，可以指向主线程上下文
t->ctx.uc_stack.ss_sp = t->stack; // 设置栈
t->ctx.uc_stack.ss_size = STACK_SIZE;// 设置栈大小
makecontext(&t->ctx, wrapfunc, 0);
cnt++;
return t;
}
void yield()
{
current->state = RUNNABLE;
schedule();
}
void join()
{
while (cnt != 0) {
yield();
}
}
void release(){
current->state = FREE;
schedule();
}
void wrapfunc()
{
current->task();
current->state = FREE;
cnt--;
schedule();
}
void fun(int id)
{
for (int i = 0; i < 5; i++) {
cout << "coroutine " << id << ": " << i << endl;
yield();
}
}
int main()
{
cout << "main start" << endl;
init();
create(std::bind(fun, 1));
create(std::bind(fun, 2));
// 全部协程结束后在main函数中退出
join();
// 释放协程资源，由创建的协程交替
// release();
cout << "main end" << endl;
return 0;
}
非对称协程实现
参考了github上云风的实现，同样使用的是ucontext.h，区别是非对称、共享栈(虽然原版作者说是共享栈，但实际上yield时保存协程栈还是为协程新开了内存，而且需要在共享栈和协程保存的栈之间拷贝，只是分配的新内存相对较小且延迟分配)以及接口不同。
主要对原协程库的一些c代码做了封装和修改，使其更加易用。
- create：创建一个协程，传入函数
- yield：挂起当前协程，由callee调用
- resume：恢复一个指定id的协程
- dead：判断一个协程是否结束
- destroy：销毁一个协程
#include <assert.h>
#include <functional>
#include <iostream>
#include <memory>
#include <random>
#include <string.h>
#include <ucontext.h>
#include <vector>
namespace coroutine
{
class CoScheduler;
class Coroutine
{
private:
enum State { FREE, RUNNABLE, RUNNING, SUSPEND };
typedef std::function<void()> Task;
friend class CoScheduler;
char *stack;
State state;
ucontext_t context;
Task task;
size_t sz;
size_t cap;
void saveStack(char *sk, size_t sksz)
{
char pos;
char *top = sk + sksz;
assert(sk < &pos);
assert(&pos < top);
if (cap < top - &pos) {
cap = top - &pos;
if (stack) {
delete[] stack;
}
stack = new char[cap];
}
sz = top - &pos;
memcpy(stack, &pos, sz);
}
public:
Coroutine(Task tk)
{
task = tk;
stack = nullptr;
sz = 0;
cap = 0;
}
void release()
{
if (stack) {
delete[] stack;
stack = nullptr;
}
sz = 0;
cap = 0;
state = FREE;
}
~Coroutine()
{
if (stack) {
delete[] stack;
}
}
bool dead() { return state == FREE; }
};
class CoScheduler
{
private:
enum { STACK_SIZE = 4096, MAX_CO = 16 };
char stack[STACK_SIZE];
std::vector<Coroutine> coroutines;
int curId;
int cnt;
ucontext_t main;
CoScheduler()
{
cnt = 0;
curId = -1;
getcontext(&main);
}
~CoScheduler()
{
for (size_t i = 0; i < coroutines.size(); i++) {
if (coroutines[i].stack) {
delete[] coroutines[i].stack;
}
}
}
public:
CoScheduler(const CoScheduler &) = delete;
CoScheduler &operator=(const CoScheduler &) = delete;
static CoScheduler &getInstance()
{
static CoScheduler sch;
return sch;
}
int createCoroutine(Coroutine::Task tk)
{
if (cnt >= MAX_CO) {
return -1;
}
int id = -1;
for (size_t i = 0; i < coroutines.size(); i++) {
if (coroutines[i].state == Coroutine::FREE) {
coroutines[i].task = tk;
id = i;
break;
}
}
if (id == -1) {
coroutines.emplace_back(tk);
id = coroutines.size() - 1;
}
cnt++;
Coroutine &co = coroutines[id];
co.state = Coroutine::RUNNABLE;
getcontext(&co.context);
co.context.uc_stack.ss_sp = stack;
co.context.uc_stack.ss_size = STACK_SIZE;
co.context.uc_link = &main;
makecontext(&co.context, (void (*)(void)) & CoScheduler::wrapFunc, 2, this, id);
return id;
}
void yield()
{
Coroutine &cur = coroutines[curId];
cur.saveStack(stack, STACK_SIZE);
cur.state = Coroutine::SUSPEND;
swapcontext(&cur.context, &main);
}
void resume(size_t id)
{
if (id >= coroutines.size() || coroutines[id].state == Coroutine::FREE) {
return;
}
if (id == curId) {
return;
}
Coroutine &next = coroutines[id];
Coroutine &cur = coroutines[curId];
curId = id;
if (next.state == Coroutine::SUSPEND) {
memcpy(stack + STACK_SIZE - next.cap, next.stack, next.cap);
}
next.state = Coroutine::RUNNING;
swapcontext(&main, &next.context);
}
void destroy(size_t id)
{
if (id >= coroutines.size() || coroutines[id].state == Coroutine::FREE) {
return;
}
coroutines[id].release();
cnt--;
}
static void wrapFunc(CoScheduler *sch, size_t id)
{
Coroutine &co = sch->coroutines[id];
co.task();
co.release();
sch->cnt--;
sch->curId = -1;
}
bool dead(size_t id) { return coroutines[id].dead(); }
void run()
{
while (cnt > 0) {
}
}
};
CoScheduler &sch = CoScheduler::getInstance();
int create(std::function<void()> tk)
{
return sch.createCoroutine(tk);
}
void resume(size_t id)
{
sch.resume(id);
}
void yield()
{
sch.yield();
}
bool dead(size_t id)
{
return sch.dead(id);
}
void destroy(size_t id)
{
sch.destroy(id);
}
} // namespace coroutine
void func(int id)
{
for (int i = 0; i < 10; i++) {
std::cout << "coroutine " << id << " : " << i << std::endl;
coroutine::yield();
}
}
void test()
{
int id1 = coroutine::create(std::bind(func, 1));
int id2 = coroutine::create(std::bind(func, 2));
assert(id1 != -1);
assert(id2 != -1);
std::cout << "main start" << std::endl;
while (!coroutine::dead(id1) && !coroutine::dead(id2)) {
coroutine::resume(id1);
coroutine::resume(id2);
}
int id3 = coroutine::create(std::bind(func, 3));
assert(id3 != -1);
int id4 = coroutine::create(std::bind(func, 4));
assert(id4 != -1);
coroutine::resume(id3);
coroutine::destroy(id3);
int id5 = coroutine::create(std::bind(func, 5));
assert(id5 != -1);
while (!coroutine::dead(id4) && !coroutine::dead(id5)) {
coroutine::resume(id4);
coroutine::resume(id5);
}
std::cout << "main end" << std::endl;
}
int main()
{
test();
}
后续还要补充一下协程在各语言中的使用
附录
补充使用汇编代码切换上下文
// swapco.S 参考了libco的实现，这里存储时没有采用bias(%rdi)的方式，而是直接更改rsp然后用push，pop
# swapco(context_t curr,context_t pending)
.globl swapco
swapco:
leaq 8(%rsp),%rax
leaq 112(%rdi),%rsp
pushq %rax
pushq %rbx
pushq %rcx
pushq %rdx
pushq -8(%rax)
pushq %rsi
pushq %rdi
pushq %rbp
pushq %r8
pushq %r9
pushq %r12
pushq %r13
pushq %r14
pushq %r15
movq %rsi, %rsp
popq %r15
popq %r14
popq %r13
popq %r12
popq %r9
popq %r8
popq %rbp
popq %rdi
popq %rsi
popq %rax
popq %rdx
popq %rcx
popq %rbx
popq %rsp
pushq %rax
xorl %eax, %eax
ret
// context.h
#ifndef _CONTEXT_H_
#define _CONTEXT_H_
#include <stddef.h>
struct context{
// 依序为
/*
0 1 2 3 4 5 6 7 8 9 10 11 12 13
r15 r14 r13 r12 r9 r8 rbp rdi rsi rip rdx rcx rbx rax
*/
void* reg[14];
};
typedef struct context* context_t;
int swapco(context_t curr, context_t pending);
int makeco(context_t newco, void* func, void* stack, size_t stack_size);
#endif
// context.c
#include "context.h"
#define ALIGNDOWN(x, a) ((x) & ~((a) - 1))
int makeco(context_t newco, void* func, void* stack, size_t stack_size){
// 返回地址
newco->reg[9] = func;
// rsp
newco->reg[13] = (void*)ALIGNDOWN((size_t)stack + stack_size, 16) - 8;
return 0;
}
// main.cpp
#include "context.h"
#include <stdio.h>
struct context mn;
struct context fc;
char stack[4096];
volatile int i = 0;
void func(){
i++;
printf("hello, world!\n");
swapco(&fc, &mn);
}
int main(){
makeco(&fc, func, stack, sizeof(stack));
swapco(&mn, &fc);
printf("i = %d\n", i);
}
/*
gcc -c swapco.S -o swapco.o
gcc swapco.o context.c main.c -o main
/*
这里有一个小细节，可以试下将makeco中改为newco->reg[13] = stack + stack_size，然后运行就能观察到Segmentation fault
使用gdb调试发现是printf相关函数的问题。
为什么printf会导致段错误？
System V AMD64 ABI 调用约定要求栈帧至少对齐至 16 字节边界，
而进入func函数时，会push rbp，此后栈帧必须要满足16字节对齐，因此需要在makeco函数中对栈指针进行对齐，必须对齐8字节而不对齐16字节
不按16字节对齐的后果？
后续在进入printf函数后，嵌套调用中存在movaps %xmm1,0x10(%rsp)指令，该指令要求内存地址是16字节对齐的，
因此如果未能按约定的那样对齐栈，在这句命令就会出现段错误
此外如果func函数需要传参的话，x86的约定顺序为rdi, rsi, rdx, rcx, r8, r9
由于makeco使用了4个寄存器，所以其它参数或者选择用r8，r9(无论是是单个传送还是用结构体指针)
或者像makecontext一样，将参数个数和参数一起传递，在函数内从寄存器或者栈中取出，放在func上下文中的参数寄存器或者栈中，为func函数调用做准备
又回看了一下调用栈(图摘自6.S081，虽然是riscv的，但就展示来看和x86的一样，对应寄存器为rsp和rbp)
依次为参数 -> 返回地址 -> 保存的寄存器 -> 局部变量
+-> .
| +-----------------+ |
| | return address | |
| | previous fp ------+
| | saved registers |
| | local variables |
| | ... | <-+
| +-----------------+ |
| | return address | |
+------ previous fp | |
| saved registers | |
| local variables | |
+-> | ... | |
| +-----------------+ |
| | return address | |
| | previous fp ------+
| | saved registers |
| | local variables |
| | ... | <-+
| +-----------------+ |
| | return address | |
+------ previous fp | |
| saved registers | |
| local variables | |
$fp --> | ... | |
+-----------------+ |
| return address | |
| previous fp ------+
| saved registers |
$sp --> | local variables |
+-----------------+
