Example #1
0
int main()
{
	coenv_t env = coroutine_init();

	myctx ctx1 = {1};
	myctx ctx2 = {2};
	myctx ctx3 = {3};

	int i;
	int co1, co2, co3;

	co1 = coroutine_new(env, cofunc, &ctx1);
	printf("coroutine_new %d\n", co1);
	co2 = coroutine_new(env, cofunc, &ctx2);
	printf("coroutine_new %d\n", co2);
	co3 = coroutine_new(env, cofunc, &ctx3);
	printf("coroutine_new %d\n", co3);

	for (i = 0; i < 10; i++)
	{
		coroutine_resume(env, co1);
		coroutine_resume(env, co2);
		coroutine_resume(env, co3);
	}

	coroutine_uninit(env);

	getchar();

	return 0;
}
Example #2
0
static void test(struct schedule *S) 
{
	struct args arg1 = { 0 };
	struct args arg2 = { 100 };

	int co1 = coroutine_new(S, foo, &arg1);
	int co2 = coroutine_new(S, foo, &arg2);
	printf("main start\n");
	while (coroutine_status(S,co1) && coroutine_status(S,co2)) {
		coroutine_resume(S,co1);
		coroutine_resume(S,co2);
	} 
	printf("main end\n");
}
void acceptfun(struct schedule *s, void *ud)
{
	int *lfd = (int *)ud;
	int *pcfd;
	struct sockaddr_in clientaddr; 
    memset(&clientaddr, 0, sizeof(struct sockaddr_in)); 
    socklen_t len = sizeof(clientaddr);
    while(1){
    	//printf("start accept..\n");
    	pcfd = (int *)malloc(sizeof(int));
    	*pcfd = accept(*lfd, (struct sockaddr *)&clientaddr, &len);
    	//printf("%d\n", *pcfd);
    	if(*pcfd == -1){
    		free(pcfd);
    		if ((errno == EAGAIN) || (errno == EWOULDBLOCK)) {
                coroutine_yield(s);
            }
            else {
                break;
            }
    	}
    	else {
    		make_socket_non_blocking(*pcfd);
    		int co = coroutine_new(s, dorequest, (void *)pcfd);
    	}
    }
}
int main()
{
	int listenfd, optval = 1;
	int i;
	int port = 9500;
	struct sockaddr_in serveraddr;
	listenfd = socket(AF_INET, SOCK_STREAM, 0);
	setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, (const void *)&optval , sizeof(int));

	bzero((char *) &serveraddr, sizeof(serveraddr));
    serveraddr.sin_family = AF_INET; 
    serveraddr.sin_addr.s_addr = htonl(INADDR_ANY); 
    serveraddr.sin_port = htons((unsigned short)port);

    bind(listenfd, (struct sockaddr *)&serveraddr, sizeof(serveraddr));

    listen(listenfd, 1024);

    make_socket_non_blocking(listenfd);

    struct schedule * S = coroutine_open();
    printf("start..\n");
    int co1 = coroutine_new(S, acceptfun, (void *)&listenfd);
    printf("%d\n", S->cap);
    printf("%d\n", co1);
    for(i = 0; i < S->cap; i++) {
    	if(coroutine_status(S, i)) {
    		coroutine_resume(S,i);
    	}
    	if(i == S->cap - 1)
    		i = -1;
    }
    coroutine_close(S);
    close(listenfd);
    return 0;
}