Cleofwine | 开发者

后端技术_协程设计原理与汇编实现

最近更新：2024-09-23 | 字数总计：765 | 阅读估时：3分钟 | 阅读量：次

同步与异步编程方式
协程——同步编程方式，异步的性能
协程的原语操作
协程的切换
仿写NtyCo（练习）

同步与异步编程方式

同步与异步是用来形容两者之间的关系的

同步(串行处理)

下一个请求将等待上一个请求返回后才执行

优势：编程简单

// 伪代码1
sync(){
    send(request);
    recv(response);
}
// 伪代码2, 检测io与操作io串行执行，检测io与读写io同步
while(1){
    epoll_wait();
    for(;;){
        recv();send();
    }
}

异步（并行处理）

下一个请求不会等待上一个返回
优势：性能高

缺陷：1.response_cb需要单独的线程不断去检测是否就绪，这样recv和send将会在不同线程共用一个fd，造成编程困难；2.假设cb里面又嵌套了请求，那么代码将会阅读更加困难。

// 伪代码1
response_cb(){
    recv();
}
async(){
    send(request, response_cb);
}
// 伪代码2，检测io与操作io分离，并行执行，检测io与操作io异步
while(1){
    epoll_wait();
    for(){
        push_thread_pool();
    } 
}

协程——同步编程方式，异步的性能

协程的原语操作

yield // 切出
resume // 切回

协程的切换

setjmp/longjmp
ucontext
asm code

ucontext

##include <stdio.h>
##include <ucontext.h>
// ucontext
// getcontext(&context);
// makecontext(&context, func, arg);
// swapcontext(&current_context, &next_context);
ucontext_t ctx[2];
ucontext_t main_ctx;
int count = 0;

void fun1(){
    while(count++ < 100){
        printf("1\n");
        swapcontext(&ctx[0], &ctx[1]);
        printf("3\n");
    }
}
void fun2(){
    while(count++ < 100){
        printf("2\n");
        swapcontext(&ctx[1], &ctx[0]);
        printf("4\n");
    }
}
int main(){
    char stack1[2048] = {0}; // ucontext不是函数，需要单独的执行栈
    char stack2[2048] = {0};
    getcontext(&ctx[0]);
    ctx[0].uc_stack.ss_sp = stack1;
    ctx[0].uc_stack.ss_size = sizeof(stack1);
    ctx[0].uc_link = &main_ctx;
    makecontext(&ctx[0], fun1, 0);

    getcontext(&ctx[1]);
    ctx[1].uc_stack.ss_sp = stack1;
    ctx[1].uc_stack.ss_size = sizeof(stack1);
    ctx[1].uc_link = &main_ctx;
    makecontext(&ctx[1], fun2, 0);

    swapcontext(&main_ctx, &ctx[0]);
}
// (fun1)1(fun2)2(fun1)31(fun2)42(fun1)31....理解上下文切换，理解与函数调用的区别

setjmp/longjmp

##include <stdio.h>
##include <setjmp.h>
jmp_buf env;

void func(int arg){
    printf("func\n");
    longjmp(env, ++arg);
    printf("longjum complete\n");
}

int main()
{
    int ret = setjmp(env);
    if(ret == 0){
        printf("ret == 0\n");
        func(ret);
    } else if (ret == 1){
        printf("ret == 1\n");
        func(ret);
    }
    printf("ret : %d\n", ret);
}
// ret == 0 setjmp函数第一次设置返回0
// func 进入func
// ret == 1 longjmp直接跳出func，回到setjmp，带的参数是1所以setjmp返回1
// func 进入func
// ret : 2 longjmp直接跳出func，回到setjmp，带的参数是2所以setjmp返回2
// *** longjmp这个函数会导致函数调用栈覆盖，所以complete语句不再会执行到，所以longjmp函数本身不会返回导致func也没有返回了

asm code

int _switch(nty_cpu_ctx *new_ctx, nty_cpu_ctx *cur_ctx);

typedef struct _nty_cpu_ctx {
    void *esp; //
    void *ebp;
    void *eip;
    void *edi;
    void *esi;
    void *ebx;
    void *r1;
    void *r2;
    void *r3;
    void *r4;
    void *r5;
} nty_cpu_ctx;

__asm__ (
    " .text \n"
    " .p2align 4,,15 \n"
    ".globl _switch \n"
    ".globl __switch \n
    "_switch: \n"
    "__switch: \n"
    " movq %rsp, 0(%rsi) # save stack_pointer \n"
    " movq %rbp, 8(%rsi) # save frame_pointer \n"
    " movq (%rsp), %rax # save insn_pointer \n"
    " movq %rax, 16(%rsi) \n"
    " movq %rbx, 24(%rsi) # save rbx,r12-r15 \n"
    " movq %r12, 32(%rsi) \n"
    " movq %r13, 40(%rsi) \n"
    " movq %r14, 48(%rsi) \n"
    " movq %r15, 56(%rsi) \n"
    " movq 56(%rdi), %r15 \n"
    " movq 48(%rdi), %r14 \n"
    " movq 40(%rdi), %r13 # restore rbx,r12-r15 \n"
    " movq 32(%rdi), %r12 \n"
    " movq 24(%rdi), %rbx \n"
    " movq 8(%rdi), %rbp # restore frame_pointer \n"
    " movq 0(%rdi), %rsp # restore stack_pointer \n"
    " movq 16(%rdi), %rax # restore insn_pointer \n"
    " movq %rax, (%rsp) \n"
    " ret \n"
);

仿写NtyCo（练习）

2024-01-29 该篇文章被 Cleofwine 归为分类: 服务端