协程库Libtask源码分析之架构篇

架构 2023-07-05 17:29:38
53阅读

 

序言:假定阅读者早已了解了协程的定义,完成协程的最底层服务支持。文中会详细介绍根据最底层基本,怎样完成协程及其协程的运用(大量基本能够点一下这儿[1])。

libtask是google大佬Russ Cox(Go的关键开发人员)所写,文中详细介绍libtask的基本基本原理。大家从libtask的main涵数逐渐,这一main涵数便是我们在c语言中应用的c涵数,libtask自身完成了main这一涵数,客户应用libtask时,要完成的是taskmain涵数。taskmain和main的函数声明是一样的。下边大家看一下main涵数。

 
  1. int main(int argc, char **argv) 
  2.     struct sigaction sa, osa; 
  3.     // 申请注册SIGQUIT信号分析涵数 
  4.     memset(&sa, 0, sizeof sa); 
  5.     sa.sa_handler = taskinfo; 
  6.     sa.sa_flags = SA_RESTART; 
  7.     sigaction(SIGQUIT, &sa, &osa); 
  8.  
  9.     // 储存命令行参数 
  10.     argv0 = argv[0]; 
  11.     taskargc = argc; 
  12.     taskargv = argv; 
  13.  
  14.     if(mainstacksize == 0) 
  15.         mainstacksize = 256*1024; 
  16.     // 建立第一个协程 
  17.     taskcreate(taskmainstart, nil, mainstacksize); 
  18.     // 逐渐生产调度 
  19.     taskscheduler(); 
  20.     fprint(2, "taskscheduler returned in main!\n"); 
  21.     abort(); 
  22.     return 0; 

main涵数关键的2个逻辑性是taskcreate和taskscheduler涵数。大家先看来taskcreate。

 
  1. int taskcreate(void (*fn)(void*), void *arg, uint stack) 
  2.     int id; 
  3.     Task *t; 
  4.  
  5.     t = taskalloc(fn, arg, stack); 
  6.     taskcount ; 
  7.     id = t->id; 
  8.     // 纪录部位 
  9.     t->alltaskslot = nalltask; 
  10.     // 储存到alltask中 
  11.     alltask[nalltask ] = t; 
  12.     // 改动情况为准备就绪,能够被生产调度,而且添加到准备就绪序列 
  13.     taskready(t); 
  14.     return id; 

taskcreate最先启用taskalloc分派一个表明协程的建筑结构Task。大家看一下这一建筑结构的界定。

 
  1. struct Task 
  2.     char    name[256];    // offset known to acid 
  3.     char    state[256]; 
  4.     // 前后左右表针 
  5.     Task    *next
  6.     Task    *prev; 
  7.     Task    *allnext; 
  8.     Task    *allprev; 
  9.     // 实行前后文 
  10.     Context    context; 
  11.     // 睡觉时间 
  12.     uvlong    alarmtime; 
  13.     uint    id; 
  14.     // 栈信息内容 
  15.     uchar    *stk; 
  16.     uint    stksize; 
  17.     //是不是撤出了 
  18.     int    exiting; 
  19.     // 在alltask的数据库索引 
  20.     int    alltaskslot; 
  21.     // 是不是系统软件协程 
  22.     int    system; 
  23.     // 是不是准备就绪情况 
  24.     int    ready; 
  25.     // 通道涵数 
  26.     void    (*startfn)(void*); 
  27.     // 通道主要参数 
  28.     void    *startarg; 
  29.     // 自定义数组 
  30.     void    *udata; 
  31. }; 

然后看一下taskalloc的完成。

 
  1. // 分派一个协程所必须的运行内存和复位一些字段名 
  2. static Task* 
  3. taskalloc(void (*fn)(void*), void *arg, uint stack) 
  4.     Task *t; 
  5.     sigset_t zero; 
  6.     uint x, y; 
  7.     ulong z; 
  8.  
  9.     /* allocate the task and stack together */ 
  10.     // 建筑结构自身的尺寸 栈尺寸 
  11.     t = malloc(sizeof *t stack); 
  12.     memset(t, 0, sizeof *t); 
  13.     // 栈的运行内存部位 
  14.     t->stk = (uchar*)(t 1); 
  15.     // 栈尺寸 
  16.     t->stksize = stack; 
  17.     // 协程id 
  18.     t->id =  taskidgen; 
  19.     // 协程工作中涵数和主要参数 
  20.     t->startfn = fn; 
  21.     t->startarg = arg; 
  22.  
  23.     /* do a reasonable initialization */ 
  24.     memset(&t->context.uc, 0, sizeof t->context.uc); 
  25.     sigemptyset(&zero); 
  26.     // 复位uc_sigmask字段名为空,即不堵塞数据信号 
  27.     sigprocmask(SIG_BLOCK, &zero, &t->context.uc.uc_sigmask); 
  28.  
  29.     /* must initialize with current context */ 
  30.     // 复位uc字段 
  31.     getcontext(&t->context.uc)  
  32.     // 设定协程实行时的栈部位和尺寸 
  33.     t->context.uc.uc_stack.ss_sp = t->stk 8; 
  34.     t->context.uc.uc_stack.ss_size = t->stksize-64; 
  35.     z = (ulong)t; 
  36.     y = z; 
  37.     z >>= 16;    /* hide undefined 32-bit shift from 32-bit compilers */ 
  38.     x = z>>16; 
  39.     // 保存信息到uc字段 
  40.     makecontext(&t->context.uc, (void(*)())taskstart, 2, y, x); 
  41.  
  42.     return t; 

taskalloc涵数编码看上去许多,可是逻辑性算不上繁杂,便是申请办理Task建筑结构需要的运行内存和实行时栈的运行内存,随后复位每个字段名。那样,一个协程就问世了。然后实行taskready把协程添加准备就绪序列。

 
  1. // 改动协程的情况为准备就绪并添加准备就绪序列 
  2. void taskready(Task *t) 
  3.     t->ready = 1; 
  4.     addtask(&taskrunqueue, t); 
  5.  
  6. // 把协程插进序列中,假如以前在别的序列,则会被清除 
  7. void addtask(Tasklist *l, Task *t) 
  8.     if(l->tail){ 
  9.         l->tail->next = t; 
  10.         t->prev = l->tail; 
  11.     }else
  12.         l->head = t; 
  13.         t->prev = nil; 
  14.     } 
  15.     l->tail = t; 
  16.     t->next = nil; 

taskrunqueue纪录了全部准备就绪的协程。建立了协程并添加序列后,协程都还没逐渐实行,如同电脑操作系统的进程和线程一样,必须有一个生产调度器来生产调度实行。下边大家看一下生产调度器的完成。

 
  1. // 协程调度系统 
  2. static void taskscheduler(void) 
  3.     int i; 
  4.     Task *t; 
  5.     for(;;){ 
  6.         // 沒有客户协程了,则撤出 
  7.         if(taskcount == 0) 
  8.             exit(taskexitval); 
  9.         // 从准备就绪序列取出一个协程 
  10.         t = taskrunqueue.head; 
  11.         if(t == nil){ 
  12.             fprint(2, "no runnable tasks! %d tasks stalled\n", taskcount); 
  13.             exit(1); 
  14.         } 
  15.         // 从准备就绪序列删掉该协程 
  16.         deltask(&taskrunqueue, t); 
  17.         t->ready = 0; 
  18.         // 储存已经实行的协程 
  19.         taskrunning = t; 
  20.         // 转换频次加一 
  21.         tasknswitch ; 
  22.         // 转换到t实行,而且储存当今前后文到taskschedcontext(即下边要实行的编码) 
  23.         contextswitch(&taskschedcontext, &t->context); 
  24.         // 实行到这表明沒有协程在实行(t转换回家的),置空 
  25.         taskrunning = nil; 
  26.         // 刚刚实行的协程t撤出了 
  27.         if(t->exiting){ 
  28.             // 并不是系统软件协程,则数量减一 
  29.             if(!t->system) 
  30.                 taskcount--; 
  31.             // 当今协程在alltask的数据库索引 
  32.             i = t->alltaskslot; 
  33.             // 把最后一个协程换到当今协程的部位,由于他要撤出了 
  34.             alltask[i] = alltask[--nalltask]; 
  35.             // 升级被换置协程的数据库索引 
  36.             alltask[i]->alltaskslot = i; 
  37.             // 释放出来堆内存 
  38.             free(t); 
  39.         } 
  40.     } 

生产调度器的编码看上去许多,可是关键逻辑性就三个 1 从准备就绪序列中取出一个协程t,并把t移除准备就绪序列 2 根据contextswitch转换到协程t中实行 3 协程t转换回调度系统,假如t早已撤出,则改动算法设计,随后收购 他占有的运行内存。假如t没撤出,则再次生产调度别的协程实行。到此,协程就逐渐跑起来了。而且也拥有智能监控系统。这儿的生产调度体制是非常简单的,便是按照先进先出法的方法准备就绪生产调度,而且是是非非占领的。即沒有按時间片生产调度的定义,一个协程的实行時间由自身决策,舍弃实行的权利也是自身操纵的,当协程不愿实行了能够启用taskyield让给cpu。

 
  1. // 协程积极让给cpu 
  2. int taskyield(void) 
  3.     int n; 
  4.     // 当今转换协程的频次 
  5.     n = tasknswitch; 
  6.     // 插进准备就绪序列,等候事后的生产调度 
  7.     taskready(taskrunning); 
  8.     taskstate("yield"); 
  9.     // 转换协程 
  10.     taskswitch(); 
  11.     // 相当于0表明当今仅有自身一个协程,生产调度的情况下tasknswitch加一,因此 这儿减一 
  12.     return tasknswitch - n - 1; 
  13.  
  14. /* 
  15.     转换协程,taskrunning是已经实行的协程,taskschedcontext是生产调度协程(主线任务程)的前后文, 
  16.     转换到调度系统,并维持当今前后文到taskrunning->context 
  17. */ 
  18. void taskswitch(void) 
  19.     needstack(0); 
  20.     contextswitch(&taskrunning->context, &taskschedcontext); 
  21.  
  22. // 真实转换协程的逻辑性 
  23. static void contextswitch(Context *from, Context *to
  24.     if(swapcontext(&from->uc, &to->uc) < 0){ 
  25.         fprint(2, "swapcontext failed: %r\n"); 
  26.         assert(0); 
  27.     } 

yield的逻辑性也非常简单,由于协程在实行的情况下,不是处在准备就绪序列的,当协程提前准备让给cpu时,协程最先把自己重进到准备就绪序列,等候下一次被生产调度实行。自然大家还可以立即生产调度contextswitch转换到别的协程。关键取决于何时应当让给cpu,又何时应当被生产调度实行。下面会详尽解读。到此,大家早已拥有适用协程所必须的最底层基本。大家见到这一完成的构思也不是很繁杂,最先有一个序列表明待实行的的协程,每一个协程相匹配一个Task建筑结构。随后调度系统不断依照先进先出法的方法去生产调度协程的实行就可以。由于沒有占领体制,因此 调度系统是依靠协程自身去驱动器的,协程必须积极让给cpu,把前后文转换回调度系统,调度系统才可以开展下一轮的生产调度。下面大家看一下,根据这种最底层基本,假如完成一个根据协程的网络服务器。下边大家根据一个事例开展解读。

 
  1. void 
  2. taskmain(int argc, char **argv) 
  3.     // 运行一个tcp网络服务器 
  4.     if((fd = netannounce(TCP, 0, atoi(argv[1]))) < 0){ 
  5.         // ... 
  6.     } 
  7.     // 改成非堵塞方式 
  8.     fdnoblock(fd); 
  9.     // accept取得成功后建立一个手机客户端协程 
  10.     while((cfd = netaccept(fd, remote, &rport)) >= 0){ 
  11.         taskcreate(proxytask, (void*)cfd, STACK); 
  12.     } 

大家刚刚讲过taskmain是大家必须完成的涵数,最先根据netannounce创建一个tcp网络服务器。然后把fd改为非堵塞的,这一十分关键,由于在后面启用accept的情况下,如果是堵塞的文件描述符,那麼便会造成过程脱机,并非堵塞方式下,电脑操作系统会回到EAGAIN的错误代码,根据这一错误代码我们可以决策下一步干什么。大家看一下netaccept的完成。

 
  1. // 解决(取下)联接 
  2. int 
  3. netaccept(int fd, char *server, int *port) 
  4.     int cfd, one; 
  5.     struct sockaddr_in sa; 
  6.     uchar *ip; 
  7.     socklen_t len; 
  8.     // 申请注册事情到epoll,等候事情开启 
  9.     fdwait(fd, 'r'); 
  10.     len = sizeof sa; 
  11.     // 开启后表明有联接了,则实行accept 
  12.     if((cfd = accept(fd, (void*)&sa, &len)) < 0){ 
  13.         return -1; 
  14.     } 
  15.     // 和手机客户端通讯的fd也改为非堵塞方式 
  16.     fdnoblock(cfd); 
  17.     one = 1; 
  18.     setsockopt(cfd, IPPROTO_TCP, TCP_NODELAY, (char*)&one, sizeof one); 
  19.     return cfd; 

netaccept便是根据启用accept逐一解决tcp连接,可是在accept以前,有一个十分关键的实际操作fdwait。

 
  1. // 协程由于等候io必须转换 
  2. void fdwait(int fd, int rw) 
  3. {     
  4.     // 是不是早已复位epoll 
  5.     if(!startedfdtask){ 
  6.         startedfdtask = 1; 
  7.         epfd = epoll_create(1); 
  8.         // 沒有复位则建立一个协程,做io管理方法 
  9.         taskcreate(fdtask, 0, 32768); 
  10.     } 
  11.     struct epoll_event ev = {0}; 
  12.     // 纪录事情相匹配的协程和很感兴趣的事情 
  13.     ev.data.ptr = taskrunning; 
  14.     switch(rw){ 
  15.     case 'r'
  16.         ev.events |= EPOLLIN | EPOLLPRI; 
  17.         break; 
  18.     case 'w'
  19.         ev.events |= EPOLLOUT; 
  20.         break; 
  21.     } 
  22.  
  23.     int r = epoll_ctl(epfd, EPOLL_CTL_ADD, fd, &ev); 
  24.     // 转换到别的协程,等候被唤起 
  25.     taskswitch(); 
  26.     // 唤起后涵数刚刚申请注册的事情 
  27.     epoll_ctl(epfd, EPOLL_CTL_DEL, fd, &ev); 

fdwait最先把fd申请注册到epoll中,随后把协程转换到下一个待实行的协程。这儿有一个关键点,当协程X被生产调度实行的情况下,他是摆脱了准备就绪序列的,而taskswitch涵数仅仅完成了转换前后文到调度系统,调度系统会从准备就绪序列从挑选下一个协程实行,那麼此刻,摆脱准备就绪序列的协程X就处在荒岛情况,看上去从此没法给调度系统选定实行,这个问题的处理方法是,把协程、fd和很感兴趣的事情信息内容一起申请注册到epoll中,当epoll监视到某一fd的事情产生时,便会把相匹配的协程添加准备就绪序列,那样协程就可以被生产调度实行了。在fdwait涵数一开始那边解决了epoll有关的逻辑性。epoll的逻辑性也是在一个协程中实行的,可是epoll所属协程和一般协程不一样,类似电脑操作系统的核心进程一样,epoll所属的协程变成系统软件协程,即并不是客户界定的,只是系统软件界定的。大家看一下完成

 
  1. void fdtask(void *v) 
  2.     int i, ms; 
  3.     Task *t; 
  4.     uvlong now; 
  5.     // 变为系统软件协程 
  6.     tasksystem(); 
  7.     struct epoll_event events[1000]; 
  8.     for(;;){ 
  9.         /* let everyone else run */ 
  10.         // 超过0表明也有别的准备就绪协程可实行,则先交给她们实行,不然向下实行 
  11.         while(taskyield() > 0) 
  12.             ; 
  13.         /* we're the only one runnable - poll for i/o */ 
  14.         errno = 0; 
  15.         // 沒有定时执行事情则一直堵塞 
  16.         if((t=sleeping.head) == nil) 
  17.             ms = -1; 
  18.         else
  19.             /* sleep at most 5s */ 
  20.             now = nsec(); 
  21.             if(now >= t->alarmtime) 
  22.                 ms = 0; 
  23.             else if(now 5*1000*1000*1000LL >= t->alarmtime) 
  24.                 ms = (t->alarmtime - now)/1000000; 
  25.             else 
  26.                 ms = 5000; 
  27.         } 
  28.         int nevents; 
  29.         // 等候事情产生,ms是等候的请求超时時间 
  30.         if((nevents = epoll_wait(epfd, events, 1000, ms)) < 0){ 
  31.             if(errno == EINTR) 
  32.                 continue
  33.             fprint(2, "epoll: %s\n", strerror(errno)); 
  34.             taskexitall(0); 
  35.         } 
  36.  
  37.         /* wake up the guys who deserve it */ 
  38.         // 事情开启,把相匹配协程插进准备就绪序列 
  39.         for(i=0; i<nevents; i ){ 
  40.             taskready((Task *)events[i].data.ptr); 
  41.         } 
  42.  
  43.         now = nsec(); 
  44.         // 解决请求超时事情 
  45.         while((t=sleeping.head) && now >= t->alarmtime){ 
  46.             deltask(&sleeping, t); 
  47.             if(!t->system && --sleepingcounted == 0) 
  48.                 taskcount--; 
  49.             taskready(t); 
  50.         } 
  51.     } 

大家见到epoll的解决逻辑性和一般网络服务器的相近,根据epoll_wait堵塞,随后epoll_wait回到时,解决每一个产生的事情,并且libtask还适用请求超时事情。此外libtask中当也有别的准备就绪协程的情况下,是不容易进到epoll_wait的,它会把cpu交给准备就绪的协程(根据taskyield涵数),当准备就绪序列仅有epoll所属的协程时才会进到epoll的逻辑性。到此,大家看到了libtask中怎样把多线程变为同歩的。当客户要启用一个很有可能会造成过程脱机的插口时,就可以启用libtask出示的一个相对的API,例如大家想报一个文档,我们可以启用libtask的fdread。

 
  1. int 
  2. fdread(int fd, void *buf, int n) 
  3.     int m; 
  4.     // 非堵塞读,假如不符合则再申请注册到epoll,参照fdread1 
  5.     while((m=read(fd, buf, n)) < 0 && errno == EAGAIN) 
  6.         fdwait(fd, 'r'); 
  7.     return m; 

那样就不用担忧过程被脱机,另外也不用解决epoll有关的逻辑性(申请注册事情,事情开启时的解决这些)。多线程转同歩,libtask的方法便是根据出示相匹配的API,先把客户的fd申请注册到epoll中,随后转换到别的协程,等epoll监视到事情开启时,便会把相匹配的协程插进准备就绪序列,当该协程被调度系统选定实行时,便会执行剩余的逻辑性而不容易造成过程脱机,由于此刻所等候的标准早已考虑。

小结:libtask的设计方案观念便是把领域模型封裝到一个个协程中,由libtask完成协程的生产调度,在每个领域模型中开展转换,进而驱动器着系统软件的运作。此外libtask也出示了一个互联网和文档io多线程变同歩的解决方法。促使大家应用起來更为便捷,高效率。今日先讲到这儿。

References

[1] 大量基本能够点一下这儿: https://github.com/theanarkh/read-libtask-code/blob/main/README.md

the end
免责声明:本文不代表本站的观点和立场,如有侵权请联系本站删除!本站仅提供信息存储空间服务。