(转)C协程实现的效率对比

前段时间实现的C协程依赖栈传递参数，在开启优化时会导致错误，于是实现了一个ucontext的版本,但ucontext的切换效率太差了，

在我的机器上执行4000W次切换需要11秒左右，这达不到我的要求，所以重新设计了实现，使得在开启优化时也能得到正确的结果.

并且效率也令人满意，4000W次切换仅需要730ms左右，足足比ucontext的实现快乐近15倍。

下面贴出实现:

 #include "uthread.h"
 #include <stdlib.h>
 #include <ucontext.h>
 #include <pthread.h>
 #include "link_list.h"

 struct uthread
 {
     int32_t reg[];//0:esp,1:ebp,2:eax,3:ebx,4:ecx,5:edx,6:edi,7:esi
     void *para;
     uthread_t parent;
     void*(*main_fun)(void*);
     void *stack;
     int32_t ssize;
     int8_t first_run;
 };

 #ifdef _DEBUG
 //for debug version
 void uthread_main_function()
 {
     int32_t arg;
      __asm__ volatile(
         "movl %%eax,%0\t\n"
         :
         :"m"(arg)
     );    

     uthread_t u = (uthread_t)arg;
     void *ret = u->main_fun(u->para);
     if(u->parent)
         uthread_switch(u,u->parent,ret);
     else
         exit();
 }
 #else
 //for release version
 void __attribute__((regparm())) uthread_main_function(void *arg)
 {
     uthread_t u = (uthread_t)arg;
     void *ret = u->main_fun(u->para);
     if(u->parent)
         uthread_switch(u,u->parent,ret);
     else
         exit();
 }
 #endif
 uthread_t uthread_create(uthread_t parent,void*stack,uint32_t stack_size,void*(*fun)(void*))
 {
     uthread_t u = (uthread_t)calloc(,sizeof(*u));
     u->parent = parent;
     u->main_fun = fun;
     u->stack = stack;
     u->ssize = stack_size;
     if(stack)
     {
         u->reg[] = (int32_t)stack+stack_size-;
         u->reg[] = (int32_t)stack+stack_size-;
     }
     if(u->main_fun)
         u->first_run = ;
     return u;
 }

 void uthread_destroy(uthread_t *u)
 {
     free(*u);
     *u = NULL;
 }

 #ifdef _DEBUG
 void* __attribute__((regparm())) uthread_switch(uthread_t from,uthread_t to,void *para)
 {
     if(!from)
         return NULL;
     to->para = para;
     int32_t esp,ebp,eax,ebx,ecx,edx,edi,esi;
     //save current registers
     //the order is important
      __asm__ volatile(
         "movl %%eax,%2\t\n"
         "movl %%ebx,%3\t\n"
         "movl %%ecx,%4\t\n"
         "movl %%edx,%5\t\n"
         "movl %%edi,%6\t\n"
         "movl %%esi,%7\t\n"
         "movl %%ebp,%1\t\n"
         "movl %%esp,%0\t\n"
         :
         :"m"(esp),"m"(ebp),"m"(eax),"m"(ebx),"m"(ecx),"m"(edx),"m"(edi),"m"(esi)
     );
     from->reg[] = esp;
     from->reg[] = ebp;
     from->reg[] = eax;
     from->reg[] = ebx;
     from->reg[] = ecx;
     from->reg[] = edx;
     from->reg[] = edi;
     from->reg[] = esi;
     if(to->first_run)
     {
        to->first_run = ;
        esp = to->reg[];
        //use eax to pass arg
        eax = (int32_t)to;
         __asm__ volatile (
             "movl %1,%%eax\t\n"
             "movl %0,%%ebp\t\n"
             "movl %%ebp,%%esp\t\n"
             :
             :"m"(esp),"m"(eax)
         );
        uthread_main_function();
     }
     else
     {
         esp = to->reg[];
         ebp = to->reg[];
         eax = to->reg[];
         ebx = to->reg[];
         ecx = to->reg[];
         edx = to->reg[];
         edi = to->reg[];
         esi = to->reg[];
         //the order is important
         __asm__ volatile (
             "movl %2,%%eax\t\n"
             "movl %3,%%ebx\t\n"
             "movl %4,%%ecx\t\n"
             "movl %5,%%edx\t\n"
             "movl %6,%%edi\t\n"
             "movl %7,%%esi\t\n"
             "movl %1,%%ebp\t\n"
             "movl %0,%%esp\t\n"
             :
             :"m"(esp),"m"(ebp),"m"(eax),"m"(ebx),"m"(ecx),"m"(edx),"m"(edi),"m"(esi)
         );
     }
     return from->para;
 }
 #else
 void* __attribute__((regparm())) uthread_switch(uthread_t from,uthread_t to,void *para)
 {
     if(!from)
         return NULL;
     to->para = para;
     int32_t esp,ebp,edi,esi;
     //save current registers
     //the order is important
      __asm__ volatile(
         "movl %%eax,%2\t\n"
         "movl %%ebx,%3\t\n"
         "movl %%ecx,%4\t\n"
         "movl %%edx,%5\t\n"
         "movl %%edi,%6\t\n"
         "movl %%esi,%7\t\n"
         "movl %%ebp,%1\t\n"
         "movl %%esp,%0\t\n"
         :
         :"m"(from->reg[]),"m"(from->reg[]),"m"(from->reg[]),"m"(from->reg[])
         ,"m"(from->reg[]),"m"(from->reg[]),"m"(from->reg[]),"m"(from->reg[])
     );
     if(to->first_run)
     {
        to->first_run = ;
        //change stack
        //the order is important
         __asm__ volatile (
             "movl %0,%%ebp\t\n"
             "movl %%ebp,%%esp\t\n"
             :
             :"m"(to->reg[])
         );
        uthread_main_function((void*)to);
     }
     else
     {
         esp = to->reg[];
         ebp = to->reg[];
         edi = to->reg[];
         esi = to->reg[];
         //the order is important
         __asm__ volatile (
             "movl %2,%%eax\t\n"
             "movl %3,%%ebx\t\n"
             "movl %4,%%ecx\t\n"
             "movl %5,%%edx\t\n"
             "movl %6,%%edi\t\n"
             "movl %7,%%esi\t\n"
             "movl %1,%%ebp\t\n"
             "movl %0,%%esp\t\n"
             :
             :"m"(esp),"m"(ebp),"m"(to->reg[]),"m"(to->reg[])
             ,"m"(to->reg[]),"m"(to->reg[]),"m"(edi),"m"(esi)
         );
     }
     return from->para;
 }
 #endif

test.c

 #include <stdio.h>
 #include "uthread.h"
 #include "SysTime.h"
 #include <stdlib.h>
 void* ufun2(void *arg)
 {
     printf("ufun2\n");
     char **tmp = (char**)arg;
     uthread_t self = (uthread_t)tmp[];
     uthread_t parent = (uthread_t)tmp[];
     volatile void *ptr = self;
     while(ptr)
     {
         ptr = uthread_switch(self,parent,NULL);
     }
     return NULL;
 }

 char *stack1;
 char *stack2;

 void* ufun1(void *arg)
 {
     uthread_t self = (uthread_t)arg;
     uthread_t u = uthread_create(self,stack2,,ufun2);
     char* _arg[];
     _arg[] = (char*)u;
     _arg[] = (char*)self;
     int i = ;
     uint32_t tick = GetSystemMs();
     for( ; i < ; ++i)
     {
         uthread_switch(self,u,&_arg[]);
     }
     printf("%d\n",GetSystemMs()-tick);
     uthread_switch(self,u,NULL);
     return arg;
 }

 int main()
 {
     stack1 = (char*)malloc();
     stack2 = (char*)malloc();
     /*
      * if use ucontext version
     char dummy_stack[4096];
     uthread_t p = uthread_create(NULL,dummy_stack,0,NULL);
     */
     uthread_t p = uthread_create(NULL,NULL,,NULL);
     uthread_t u = uthread_create(p,stack1,,ufun1);
     uthread_switch(p,u,u);
     printf("main end\n");
     return ;
 };

转自：https://www.cnblogs.com/sniperHW/archive/2012/08/05/2624334.html