Prefácio : Entrei em contato com o conceito de co-rotina há alguns dias e achei muito interessante. Porque posso usar um thread para implementar um programa multi-threaded, se eu usar uma co-rotina em vez de um thread, posso salvar muitas operações atômicas e barreiras de memória e reduzir significativamente as chamadas do sistema relacionadas à sincronização de thread. Porque eu só tenho um thread, e a alternância entre as co-rotinas pode ser determinada pela própria função.
1. Introdução
Já vi várias implementações de corrotinas. Como não há suporte nativo para C / C ++, a maioria das bibliotecas usa código assembly e algumas bibliotecas usam setjmp e longjmp da linguagem C, mas exigem o uso de variáveis locais estáticas na função. Salve os dados dentro da co-rotina. Eu odeio escrever assembly e usar variáveis locais estáticas, então eu vim com uma maneira um pouco mais elegante e inteligente de implementá-lo. Este artigo mostrará os princípios básicos e a implementação desse método.
2. Princípios básicos
A maior dificuldade na implementação de C / C ++ é criar, salvar e restaurar o contexto do programa. Porque isso envolve o gerenciamento da pilha do programa e o acesso aos registros da CPU, mas esses dois conteúdos não são estritamente definidos no padrão C / C ++, então é impossível para nós ter uma implementação C / C ++ completamente multiplataforma. Mas usando a API fornecida pelo sistema operacional, ainda podemos evitar o uso de código assembly.A seguir, mostraremos a você uma estrutura de corrotina simples implementada usando o pthread do POSIX. o que! ? ? Pthread? Seu programa não é multithread? Isso ainda é chamado de co-rotina! Sim, é realmente multi-threaded, mas apenas por um breve momento antes de a co-rotina ser criada.
Para criar o contexto da sub-rotina, podemos chamar a função pthread_create para criar uma thread real, de modo que o sistema operacional nos ajude a criar o contexto (incluindo a inicialização dos registradores da CPU e da pilha do programa). Então, quando o thread for iniciado, use o setjmp da linguagem C para fazer backup desses registros no buffer externo. Após a criação, o thread perde seu valor de existência, portanto, pode ser eliminado de forma decisiva. No entanto, deve-se observar que antes de criar uma thread, você precisa chamar a função pthread_attr_setstack para declarar explicitamente a pilha do programa usada, de forma que, quando a thread sair, o sistema não destrua automaticamente a pilha do programa. Quanto à recuperação de contexto, obviamente a função longjmp é usada.
Três, crie um contexto
Abaixo está a definição de RoutineInfo. Por questões de simplicidade, todos os códigos de tratamento de erros foram omitidos.O código original está no arquivo coroutine.cpp e o código omitido está no arquivo coroutine_demonstration.cpp.
typedef void * (*RoutineHandler)(void*);
struct RoutineInfo{
void * param;
RoutineHandler handler;
void * ret;
bool stopped;
jmp_buf buf;
void *stackbase;
size_t stacksize;
pthread_attr_t attr;
// size: the stack size
RoutineInfo(size_t size){
param = NULL;
handler = NULL;
ret = NULL;
stopped = false;
stackbase = malloc(size);
stacksize = size;
pthread_attr_init(&attr);
if(stacksize)
pthread_attr_setstack(&attr,stackbase,stacksize);
}
~RoutineInfo(){
pthread_attr_destroy(&attr);
free(stackbase);
}
};
Então, precisamos de uma lista global para salvar esses objetos RoutineInfo.
std::list<RoutineInfo*> InitRoutines(){
std::list<RoutineInfo*> list;
RoutineInfo *main = new RoutineInfo(0);
list.push_back(main);
return list;
}
std::list<RoutineInfo*> routines = InitRoutines();
A seguir está a criação da co-rotina.Note que quando a co-rotina está em andamento, a pilha do programa pode ter sido danificada, então um stackBack é necessário como um backup da pilha do programa para recuperação posterior.
void *stackBackup = NULL;
void *CoroutineStart(void *pRoutineInfo);
int CreateCoroutine(RoutineHandler handler,void* param ){
RoutineInfo* info = new RoutineInfo(PTHREAD_STACK_MIN+ 0x4000);
info->param = param;
info->handler = handler;
pthread_t thread;
int ret = pthread_create( &thread, &(info->attr), CoroutineStart, info);
void* status;
pthread_join(thread,&status);
memcpy(info->stackbase,stackBackup,info->stacksize); // restore the stack
routines.push_back(info); // add the routine to the end of the list
return 0;
}
Depois, há a função CoroutinneStart. Quando o encadeamento entrar nessa função, use setjmp para salvar o contexto, faça backup de sua própria pilha de programa e saia do encadeamento diretamente.
void Switch();
void *CoroutineStart(void *pRoutineInfo){
RoutineInfo& info = *(RoutineInfo*)pRoutineInfo;
if( !setjmp(info.buf)){
// back up the stack, and then exit
stackBackup = realloc(stackBackup,info.stacksize);
memcpy(stackBackup,info.stackbase, info.stacksize);
pthread_exit(NULL);
return (void*)0;
}
info.ret = info.handler(info.param);
info.stopped = true;
Switch(); // never return
return (void*)0; // suppress compiler warning
}
Quatro, mudança de contexto
Uma co-rotina chama ativamente a função Switch () antes de mudar para outra co-rotina.
std::list<RoutineInfo*> stoppedRoutines = std::list<RoutineInfo*>();
void Switch(){
RoutineInfo* current = routines.front();
routines.pop_front();
if(current->stopped){
// The stack is stored in the RoutineInfo object,
// delete the object later, now know
stoppedRoutines.push_back(current);
longjmp( (*routines.begin())->buf ,1);
}
routines.push_back(current); // adjust the routines to the end of list
if( !setjmp(current->buf) ){
longjmp( (*routines.begin())->buf ,1);
}
if(stoppedRoutines.size()){
delete stoppedRoutines.front();
stoppedRoutines.pop_front();
}
}
Five, demo
O código do usuário é muito simples, assim como usar uma biblioteca de threads, uma co-rotina chama ativamente a função Switch () para ceder ativamente o tempo de CPU para outra co-rotina.
#include <iostream>
using namespace std;
#include <sys/wait.h>
void* foo(void*){
for(int i=0; i<2; ++i){
cout<<"foo: "<<i<<endl;
sleep(1);
Switch();
}
}
int main(){
CreateCoroutine(foo,NULL);
for(int i=0; i<6; ++i){
cout<<"main: "<<i<<endl;
sleep(1);
Switch();
}
}
Lembre-se de adicionar a opção de link -lpthread ao vincular. O resultado da execução do programa é o seguinte:
[roxma@VM_6_207_centos coroutine]$ g++ coroutime_demonstration.cpp -lpthread -o a.out
[roxma@VM_6_207_centos coroutine]$ ls
a.out coroutime.cpp coroutime_demonstration.cpp README.md
[roxma@VM_6_207_centos coroutine]$ ./a.out
main: 0
foo: 0
main: 1
foo: 1
main: 2
main: 3
main: 4
main: 5