├── .gitignore
├── LICENSE.txt
├── Makefile
├── README.md
├── co.mk
├── co_closure.h
├── co_epoll.cpp
├── co_epoll.h
├── co_hook_sys_call.cpp
├── co_routine.cpp
├── co_routine.h
├── co_routine_inner.h
├── co_routine_specific.h
├── coctx.cpp
├── coctx.h
├── coctx_swap.S
├── example_closure.cpp
├── example_cond.cpp
├── example_copystack.cpp
├── example_echocli.cpp
├── example_echosvr.cpp
├── example_poll.cpp
├── example_setenv.cpp
├── example_specific.cpp
└── example_thread.cpp


/.gitignore:
--------------------------------------------------------------------------------
1 | BUILD


--------------------------------------------------------------------------------
/LICENSE.txt:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/tencent-wechat/libco/12878a93c9b345a3c175418affb214e6d5034d7e/LICENSE.txt


--------------------------------------------------------------------------------
/Makefile:
--------------------------------------------------------------------------------
 1 | #
 2 | # Tencent is pleased to support the open source community by making Libco available.
 3 | # 
 4 | # Copyright (C) 2014 THL A29 Limited, a Tencent company. All rights reserved.
 5 | # 
 6 | # Licensed under the Apache License, Version 2.0 (the "License"); 
 7 | # you may not use this file except in compliance with the License. 
 8 | # You may obtain a copy of the License at
 9 | # 
10 | #   http://www.apache.org/licenses/LICENSE-2.0
11 | # 
12 | # Unless required by applicable law or agreed to in writing, 
13 | # software distributed under the License is distributed on an "AS IS" BASIS, 
14 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
15 | # See the License for the specific language governing permissions and 
16 | # limitations under the License.
17 | #
18 | 
19 | 
20 | COMM_MAKE = 1
21 | COMM_ECHO = 1
22 | version=0.5
23 | v=debug
24 | include co.mk
25 | 
26 | ########## options ##########
27 | CFLAGS += -g -fno-strict-aliasing -O2 -Wall -export-dynamic \
28 | 	-Wall -pipe  -D_GNU_SOURCE -D_REENTRANT -fPIC -Wno-deprecated -m64
29 | 
30 | LINKS += -g -L./lib -lcolib -lpthread -ldl 
31 | 
32 | COLIB_OBJS=co_epoll.o co_routine.o co_hook_sys_call.o coctx_swap.o coctx.o
33 | #co_swapcontext.o
34 | 
35 | PROGS = colib example_poll example_echosvr example_echocli example_thread  example_cond example_specific example_copystack example_closure
36 | 
37 | all:$(PROGS)
38 | 
39 | colib:libcolib.a libcolib.so
40 | 
41 | libcolib.a: $(COLIB_OBJS)
42 | 	$(ARSTATICLIB) 
43 | libcolib.so: $(COLIB_OBJS)
44 | 	$(BUILDSHARELIB) 
45 | 
46 | example_echosvr:example_echosvr.o
47 | 	$(BUILDEXE) 
48 | example_echocli:example_echocli.o
49 | 	$(BUILDEXE) 
50 | example_thread:example_thread.o
51 | 	$(BUILDEXE) 
52 | example_poll:example_poll.o
53 | 	$(BUILDEXE) 
54 | example_exit:example_exit.o
55 | 	$(BUILDEXE) 
56 | example_cond:example_cond.o
57 | 	$(BUILDEXE)
58 | example_specific:example_specific.o
59 | 	$(BUILDEXE)
60 | example_copystack:example_copystack.o
61 | 	$(BUILDEXE)
62 | example_setenv:example_setenv.o
63 | 	$(BUILDEXE)
64 | example_closure:example_closure.o
65 | 	$(BUILDEXE)
66 | 
67 | dist: clean libco-$(version).src.tar.gz
68 | 
69 | libco-$(version).src.tar.gz:
70 | 	@find . -type f | grep -v CVS | grep -v .svn | sed s:^./:libco-$(version)/: > MANIFEST
71 | 	@(cd ..; ln -s libco_pub libco-$(version))
72 | 	(cd ..; tar cvf - `cat libco_pub/MANIFEST` | gzip > libco_pub/libco-$(version).src.tar.gz)
73 | 	@(cd ..; rm libco-$(version))
74 | 
75 | clean:
76 | 	$(CLEAN) *.o $(PROGS)
77 | 	rm -fr MANIFEST lib solib libco-$(version).src.tar.gz libco-$(version)
78 | 
79 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | 本库已转至 <a>http://github.com/Tencent/libco</a>
2 | 


--------------------------------------------------------------------------------
/co.mk:
--------------------------------------------------------------------------------
 1 | #
 2 | # Tencent is pleased to support the open source community by making Libco available.
 3 | #
 4 | # Copyright (C) 2014 THL A29 Limited, a Tencent company. All rights reserved.
 5 | #
 6 | # Licensed under the Apache License, Version 2.0 (the "License"); 
 7 | # you may not use this file except in compliance with the License. 
 8 | # You may obtain a copy of the License at
 9 | #
10 | #	http://www.apache.org/licenses/LICENSE-2.0
11 | #
12 | # Unless required by applicable law or agreed to in writing, 
13 | # software distributed under the License is distributed on an "AS IS" BASIS, 
14 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
15 | # See the License for the specific language governing permissions and 
16 | # limitations under the License.
17 | #
18 | 
19 | 
20 | 
21 | ##### Makefile Rules ##########
22 | MAIL_ROOT=.
23 | SRCROOT=.
24 | 
25 | ##define the compliers
26 | CPP = g++
27 | CC  = gcc
28 | AR = ar -rc
29 | RANLIB = ranlib
30 | 
31 | CPPSHARE = $(CPP) -fPIC -shared -O2 -pipe -L$(SRCROOT)/solib/ -o 
32 | CSHARE = $(CC) -fPIC -shared -O2 -pipe -L$(SRCROOT)/solib/ -o 
33 | 
34 | ifeq ($v,release)
35 | CFLAGS= -O2 $(INCLS) -fPIC  -DLINUX -pipe -Wno-deprecated -c
36 | else
37 | CFLAGS= -g $(INCLS) -fPIC -DLINUX -pipe -c -fno-inline
38 | endif
39 | 
40 | ifneq ($v,release)
41 | BFLAGS= -g
42 | endif
43 | 
44 | STATICLIBPATH=$(SRCROOT)/lib
45 | DYNAMICLIBPATH=$(SRCROOT)/solib
46 | 
47 | INCLS += -I$(SRCROOT)
48 | 
49 | ## default links
50 | ifeq ($(LINKS_DYNAMIC), 1)
51 | LINKS += -L$(DYNAMICLIBPATH) -L$(STATICLIBPATH)
52 | else
53 | LINKS += -L$(STATICLIBPATH)
54 | endif
55 | 
56 | CPPSRCS  = $(wildcard *.cpp)
57 | CSRCS  = $(wildcard *.c)
58 | CPPOBJS  = $(patsubst %.cpp,%.o,$(CPPSRCS))
59 | COBJS  = $(patsubst %.c,%.o,$(CSRCS))
60 | 
61 | SRCS = $(CPPSRCS) $(CSRCS)
62 | OBJS = $(CPPOBJS) $(COBJS)
63 | 
64 | CPPCOMPI=$(CPP) $(CFLAGS) -Wno-deprecated
65 | CCCOMPI=$(CC) $(CFLAGS)
66 | 
67 | BUILDEXE = $(CPP) $(BFLAGS) -o $@ $^ $(LINKS) 
68 | CLEAN = rm -f *.o 
69 | 
70 | CPPCOMPILE = $(CPPCOMPI) $< $(FLAGS) $(INCLS) $(MTOOL_INCL) -o $@
71 | CCCOMPILE = $(CCCOMPI) $< $(FLAGS) $(INCLS) $(MTOOL_INCL) -o $@
72 | 
73 | ARSTATICLIB = $(AR) $@.tmp $^ $(AR_FLAGS); \
74 | 			  if [ $$? -ne 0 ]; then exit 1; fi; \
75 | 			  test -d $(STATICLIBPATH) || mkdir -p $(STATICLIBPATH); \
76 | 			  mv -f $@.tmp $(STATICLIBPATH)/$@;
77 | 
78 | BUILDSHARELIB = $(CPPSHARE) $@.tmp $^ $(BS_FLAGS); \
79 | 				if [ $$? -ne 0 ]; then exit 1; fi; \
80 | 				test -d $(DYNAMICLIBPATH) || mkdir -p $(DYNAMICLIBPATH); \
81 | 				mv -f $@.tmp $(DYNAMICLIBPATH)/$@;
82 | 
83 | .cpp.o:
84 | 	$(CPPCOMPILE)
85 | .c.o:
86 | 	$(CCCOMPILE)
87 | 


--------------------------------------------------------------------------------
/co_closure.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | * Tencent is pleased to support the open source community by making Libco available.
 3 | 
 4 | * Copyright (C) 2014 THL A29 Limited, a Tencent company. All rights reserved.
 5 | *
 6 | * Licensed under the Apache License, Version 2.0 (the "License"); 
 7 | * you may not use this file except in compliance with the License. 
 8 | * You may obtain a copy of the License at
 9 | *
10 | *	http://www.apache.org/licenses/LICENSE-2.0
11 | *
12 | * Unless required by applicable law or agreed to in writing, 
13 | * software distributed under the License is distributed on an "AS IS" BASIS, 
14 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
15 | * See the License for the specific language governing permissions and 
16 | * limitations under the License.
17 | */
18 | 
19 | #ifndef __CO_CLOSURE_H__
20 | #define __CO_CLOSURE_H__
21 | struct stCoClosure_t 
22 | {
23 | public:
24 | 	virtual void exec() = 0;
25 | };
26 | 
27 | //1.base 
28 | //-- 1.1 comac_argc
29 | 
30 | #define comac_get_args_cnt( ... ) comac_arg_n( __VA_ARGS__ )
31 | #define comac_arg_n( _1,_2,_3,_4,_5,_6,_7,N,...) N
32 | #define comac_args_seqs() 7,6,5,4,3,2,1,0
33 | #define comac_join_1( x,y ) x##y
34 | 
35 | #define comac_argc( ... ) comac_get_args_cnt( __VA_ARGS__,comac_args_seqs() )
36 | #define comac_join( x,y) comac_join_1( x,y )
37 | 
38 | //-- 1.2 repeat
39 | #define repeat_0( fun,a,... ) 
40 | #define repeat_1( fun,a,... ) fun( 1,a,__VA_ARGS__ ) repeat_0( fun,__VA_ARGS__ )
41 | #define repeat_2( fun,a,... ) fun( 2,a,__VA_ARGS__ ) repeat_1( fun,__VA_ARGS__ )
42 | #define repeat_3( fun,a,... ) fun( 3,a,__VA_ARGS__ ) repeat_2( fun,__VA_ARGS__ )
43 | #define repeat_4( fun,a,... ) fun( 4,a,__VA_ARGS__ ) repeat_3( fun,__VA_ARGS__ )
44 | #define repeat_5( fun,a,... ) fun( 5,a,__VA_ARGS__ ) repeat_4( fun,__VA_ARGS__ )
45 | #define repeat_6( fun,a,... ) fun( 6,a,__VA_ARGS__ ) repeat_5( fun,__VA_ARGS__ )
46 | 
47 | #define repeat( n,fun,... ) comac_join( repeat_,n )( fun,__VA_ARGS__)
48 | 
49 | //2.implement
50 | #define decl_typeof( i,a,... ) typedef typeof( a ) typeof_##a;
51 | #define impl_typeof( i,a,... ) typeof_##a & a;
52 | #define impl_typeof_cpy( i,a,... ) typeof_##a a;
53 | #define con_param_typeof( i,a,... ) typeof_##a & a##r,
54 | #define param_init_typeof( i,a,... ) a(a##r),
55 | 
56 | 
57 | //2.1 reference
58 | 
59 | #define co_ref( name,... )\
60 | repeat( comac_argc(__VA_ARGS__) ,decl_typeof,__VA_ARGS__ )\
61 | class type_##name\
62 | {\
63 | public:\
64 | 	repeat( comac_argc(__VA_ARGS__) ,impl_typeof,__VA_ARGS__ )\
65 | 	int _member_cnt;\
66 | 	type_##name( \
67 | 		repeat( comac_argc(__VA_ARGS__),con_param_typeof,__VA_ARGS__ ) ... ): \
68 | 		repeat( comac_argc(__VA_ARGS__),param_init_typeof,__VA_ARGS__ ) _member_cnt(comac_argc(__VA_ARGS__)) \
69 | 	{}\
70 | } name( __VA_ARGS__ ) ;
71 | 
72 | 
73 | //2.2 function
74 | 
75 | #define co_func(name,...)\
76 | repeat( comac_argc(__VA_ARGS__) ,decl_typeof,__VA_ARGS__ )\
77 | class name:public stCoClosure_t\
78 | {\
79 | public:\
80 | 	repeat( comac_argc(__VA_ARGS__) ,impl_typeof_cpy,__VA_ARGS__ )\
81 | 	int _member_cnt;\
82 | public:\
83 | 	name( repeat( comac_argc(__VA_ARGS__),con_param_typeof,__VA_ARGS__ ) ... ): \
84 | 		repeat( comac_argc(__VA_ARGS__),param_init_typeof,__VA_ARGS__ ) _member_cnt(comac_argc(__VA_ARGS__))\
85 | 	{}\
86 | 	void exec()
87 | 
88 | #define co_func_end }
89 | 
90 | 
91 | #endif
92 | 
93 | 


--------------------------------------------------------------------------------
/co_epoll.cpp:
--------------------------------------------------------------------------------
  1 | /*
  2 | * Tencent is pleased to support the open source community by making Libco available.
  3 | 
  4 | * Copyright (C) 2014 THL A29 Limited, a Tencent company. All rights reserved.
  5 | *
  6 | * Licensed under the Apache License, Version 2.0 (the "License"); 
  7 | * you may not use this file except in compliance with the License. 
  8 | * You may obtain a copy of the License at
  9 | *
 10 | *	http://www.apache.org/licenses/LICENSE-2.0
 11 | *
 12 | * Unless required by applicable law or agreed to in writing, 
 13 | * software distributed under the License is distributed on an "AS IS" BASIS, 
 14 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
 15 | * See the License for the specific language governing permissions and 
 16 | * limitations under the License.
 17 | */
 18 | 
 19 | #include "co_epoll.h"
 20 | #include <stdlib.h>
 21 | #include <stdio.h>
 22 | #include <errno.h>
 23 | #include <string.h>
 24 | #include <string.h>
 25 | 
 26 | #ifndef __APPLE__
 27 | 
 28 | int	co_epoll_wait( int epfd,struct co_epoll_res *events,int maxevents,int timeout )
 29 | {
 30 | 	return epoll_wait( epfd,events->events,maxevents,timeout );
 31 | }
 32 | int	co_epoll_ctl( int epfd,int op,int fd,struct epoll_event * ev )
 33 | {
 34 | 	return epoll_ctl( epfd,op,fd,ev );
 35 | }
 36 | int	co_epoll_create( int size )
 37 | {
 38 | 	return epoll_create( size );
 39 | }
 40 | 
 41 | struct co_epoll_res *co_epoll_res_alloc( int n )
 42 | {
 43 | 	struct co_epoll_res * ptr = 
 44 | 		(struct co_epoll_res *)malloc( sizeof( struct co_epoll_res ) );
 45 | 
 46 | 	ptr->size = n;
 47 | 	ptr->events = (struct epoll_event*)calloc( 1,n * sizeof( struct epoll_event ) );
 48 | 
 49 | 	return ptr;
 50 | 
 51 | }
 52 | void co_epoll_res_free( struct co_epoll_res * ptr )
 53 | {
 54 | 	if( !ptr ) return;
 55 | 	if( ptr->events ) free( ptr->events );
 56 | 	free( ptr );
 57 | }
 58 | 
 59 | #else
 60 | class clsFdMap // million of fd , 1024 * 1024 
 61 | {
 62 | private:
 63 | 	static const int row_size = 1024;
 64 | 	static const int col_size = 1024;
 65 | 
 66 | 	void **m_pp[ 1024 ];
 67 | public:
 68 | 	clsFdMap()
 69 | 	{
 70 | 		memset( m_pp,0,sizeof(m_pp) );
 71 | 	}
 72 | 	~clsFdMap()
 73 | 	{
 74 | 		for(int i=0;i<sizeof(m_pp)/sizeof(m_pp[0]);i++)
 75 | 		{
 76 | 			if( m_pp[i] ) 
 77 | 			{
 78 | 				free( m_pp[i] );
 79 | 				m_pp[i] = NULL;
 80 | 			}
 81 | 		}
 82 | 	}
 83 | 	inline int clear( int fd )
 84 | 	{
 85 | 		set( fd,NULL );
 86 | 		return 0;
 87 | 	}
 88 | 	inline int set( int fd,const void * ptr )
 89 | 	{
 90 | 		int idx = fd / row_size;
 91 | 		if( idx < 0 || idx >= sizeof(m_pp)/sizeof(m_pp[0]) )
 92 | 		{
 93 | 			assert( __LINE__ == 0 );
 94 | 			return -__LINE__;
 95 | 		}
 96 | 		if( !m_pp[ idx ] ) 
 97 | 		{
 98 | 			m_pp[ idx ] = (void**)calloc( 1,sizeof(void*) * col_size );
 99 | 		}
100 | 		m_pp[ idx ][ fd % col_size ] = (void*)ptr;
101 | 		return 0;
102 | 	}
103 | 	inline void *get( int fd )
104 | 	{
105 | 		int idx = fd / row_size;
106 | 		if( idx < 0 || idx >= sizeof(m_pp)/sizeof(m_pp[0]) )
107 | 		{
108 | 			return NULL;
109 | 		}
110 | 		void **lp = m_pp[ idx ];
111 | 		if( !lp ) return NULL;
112 | 
113 | 		return lp[ fd % col_size ];
114 | 	}
115 | };
116 | 
117 | __thread clsFdMap *s_fd_map = NULL;
118 | 
119 | static inline clsFdMap *get_fd_map()
120 | {
121 | 	if( !s_fd_map )
122 | 	{
123 | 		s_fd_map = new clsFdMap();
124 | 	}
125 | 	return s_fd_map;
126 | }
127 | 
128 | struct kevent_pair_t
129 | {
130 | 	int fire_idx;
131 | 	int events;
132 | 	uint64_t u64;
133 | };
134 | int co_epoll_create( int size )
135 | {
136 | 	return kqueue();
137 | }
138 | int co_epoll_wait( int epfd,struct co_epoll_res *events,int maxevents,int timeout )
139 | {
140 | 	struct timespec t = { 0 };
141 | 	if( timeout > 0 )
142 | 	{
143 | 		t.tv_sec = timeout;
144 | 	}
145 | 	int ret = kevent( epfd, 
146 | 					NULL, 0, //register null
147 | 					events->eventlist, maxevents,//just retrival
148 | 					( -1 == timeout ) ? NULL : &t );
149 | 	int j = 0;
150 | 	for(int i=0;i<ret;i++)
151 | 	{
152 | 		struct kevent &kev = events->eventlist[i];
153 | 		struct kevent_pair_t *ptr = (struct kevent_pair_t*)kev.udata;
154 | 		struct epoll_event *ev = events->events + i;
155 | 		if( 0 == ptr->fire_idx )
156 | 		{
157 | 			ptr->fire_idx = i + 1;
158 | 			memset( ev,0,sizeof(*ev) );
159 | 			++j;
160 | 		}
161 | 		else
162 | 		{
163 | 			ev = events->events + ptr->fire_idx - 1;
164 | 		}
165 | 		if( EVFILT_READ == kev.filter )
166 | 		{
167 | 			ev->events |= EPOLLIN;
168 | 		}
169 | 		else if( EVFILT_WRITE == kev.filter )
170 | 		{
171 | 			ev->events |= EPOLLOUT;
172 | 		}
173 | 		ev->data.u64 = ptr->u64;
174 | 	}
175 | 	for(int i=0;i<ret;i++)
176 | 	{
177 | 		(( struct kevent_pair_t* )(events->eventlist[i].udata) )->fire_idx = 0;
178 | 	}
179 | 	return j;
180 | }
181 | int co_epoll_del( int epfd,int fd )
182 | {
183 | 
184 | 	struct timespec t = { 0 };
185 | 	struct kevent_pair_t *ptr = ( struct kevent_pair_t* )get_fd_map()->get( fd );
186 | 	if( !ptr ) return 0;
187 | 	if( EPOLLIN & ptr->events )
188 | 	{
189 | 		struct kevent kev = { 0 };
190 | 		kev.ident = fd;
191 | 		kev.filter = EVFILT_READ;
192 | 		kev.flags = EV_DELETE;
193 | 		kevent( epfd,&kev,1, NULL,0,&t );
194 | 	}
195 | 	if( EPOLLOUT & ptr->events )
196 | 	{
197 | 		struct kevent kev = { 0 };
198 | 		kev.ident = fd;
199 | 		kev.filter = EVFILT_WRITE;
200 | 		kev.flags = EV_DELETE;
201 | 		kevent( epfd,&kev,1, NULL,0,&t );
202 | 	}
203 | 	get_fd_map()->clear( fd );
204 | 	free( ptr );
205 | 	return 0;
206 | }
207 | int co_epoll_ctl( int epfd,int op,int fd,struct epoll_event * ev )
208 | {
209 | 	if( EPOLL_CTL_DEL == op )
210 | 	{
211 | 		return co_epoll_del( epfd,fd );
212 | 	}
213 | 
214 | 	const int flags = ( EPOLLIN | EPOLLOUT | EPOLLERR | EPOLLHUP );
215 | 	if( ev->events & ~flags ) 
216 | 	{
217 | 		return -1;
218 | 	}
219 | 
220 | 	if( EPOLL_CTL_ADD == op && get_fd_map()->get( fd ) )
221 | 	{
222 | 		errno = EEXIST;
223 | 		return -1;
224 | 	}
225 | 	else if( EPOLL_CTL_MOD == op && !get_fd_map()->get( fd ) )
226 | 	{
227 | 		errno = ENOENT;
228 | 		return -1;
229 | 	}
230 | 
231 | 	struct kevent_pair_t *ptr = (struct kevent_pair_t*)get_fd_map()->get( fd );
232 | 	if( !ptr )
233 | 	{
234 | 		ptr = (kevent_pair_t*)calloc(1,sizeof(kevent_pair_t));
235 | 		get_fd_map()->set( fd,ptr );
236 | 	}
237 | 
238 | 	int ret = 0;
239 | 	struct timespec t = { 0 };
240 | 
241 | 	printf("ptr->events 0x%X\n",ptr->events);
242 | 
243 | 	if( EPOLL_CTL_MOD == op )
244 | 	{
245 | 		//1.delete if exists
246 | 		if( ptr->events & EPOLLIN ) 
247 | 		{
248 | 			struct kevent kev = { 0 };
249 | 			EV_SET( &kev,fd,EVFILT_READ,EV_DELETE,0,0,NULL );
250 | 			kevent( epfd, &kev,1, NULL,0, &t );
251 | 		}	
252 | 		//1.delete if exists
253 | 		if( ptr->events & EPOLLOUT ) 
254 | 		{
255 | 			struct kevent kev = { 0 };
256 | 			EV_SET( &kev,fd,EVFILT_WRITE,EV_DELETE,0,0,NULL );
257 | 			ret = kevent( epfd, &kev,1, NULL,0, &t );
258 | 			printf("delete write ret %d\n",ret );
259 | 		}
260 | 	}
261 | 
262 | 	do
263 | 	{
264 | 		if( ev->events & EPOLLIN )
265 | 		{
266 | 			
267 | 			//2.add
268 | 			struct kevent kev = { 0 };
269 | 			EV_SET( &kev,fd,EVFILT_READ,EV_ADD,0,0,ptr );
270 | 			ret = kevent( epfd, &kev,1, NULL,0, &t );
271 | 			if( ret ) break;
272 | 		}
273 | 		if( ev->events & EPOLLOUT )
274 | 		{
275 | 				//2.add
276 | 			struct kevent kev = { 0 };
277 | 			EV_SET( &kev,fd,EVFILT_WRITE,EV_ADD,0,0,ptr );
278 | 			ret = kevent( epfd, &kev,1, NULL,0, &t );
279 | 			if( ret ) break;
280 | 		}
281 | 	} while( 0 );
282 | 	
283 | 	if( ret )
284 | 	{
285 | 		get_fd_map()->clear( fd );
286 | 		free( ptr );
287 | 		return ret;
288 | 	}
289 | 
290 | 	ptr->events = ev->events;
291 | 	ptr->u64 = ev->data.u64;
292 | 	 
293 | 
294 | 	return ret;
295 | }
296 | 
297 | struct co_epoll_res *co_epoll_res_alloc( int n )
298 | {
299 | 	struct co_epoll_res * ptr = 
300 | 		(struct co_epoll_res *)malloc( sizeof( struct co_epoll_res ) );
301 | 
302 | 	ptr->size = n;
303 | 	ptr->events = (struct epoll_event*)calloc( 1,n * sizeof( struct epoll_event ) );
304 | 	ptr->eventlist = (struct kevent*)calloc( 1,n * sizeof( struct kevent) );
305 | 
306 | 	return ptr;
307 | }
308 | 
309 | void co_epoll_res_free( struct co_epoll_res * ptr )
310 | {
311 | 	if( !ptr ) return;
312 | 	if( ptr->events ) free( ptr->events );
313 | 	if( ptr->eventlist ) free( ptr->eventlist );
314 | 	free( ptr );
315 | }
316 | 
317 | #endif
318 | 
319 | 
320 | 


--------------------------------------------------------------------------------
/co_epoll.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | * Tencent is pleased to support the open source community by making Libco available.
 3 | 
 4 | * Copyright (C) 2014 THL A29 Limited, a Tencent company. All rights reserved.
 5 | *
 6 | * Licensed under the Apache License, Version 2.0 (the "License"); 
 7 | * you may not use this file except in compliance with the License. 
 8 | * You may obtain a copy of the License at
 9 | *
10 | *	http://www.apache.org/licenses/LICENSE-2.0
11 | *
12 | * Unless required by applicable law or agreed to in writing, 
13 | * software distributed under the License is distributed on an "AS IS" BASIS, 
14 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
15 | * See the License for the specific language governing permissions and 
16 | * limitations under the License.
17 | */
18 | 
19 | #ifndef __CO_EPOLL_H__
20 | #define __CO_EPOLL_H__
21 | #include <stdint.h>
22 | #include <stdlib.h>
23 | #include <assert.h>
24 | #include <string.h>
25 | #include <sys/types.h>
26 | #include <time.h>
27 | #include <time.h>
28 | 
29 | #ifndef __APPLE__
30 | 
31 | #include <sys/epoll.h>
32 | 
33 | struct co_epoll_res
34 | {
35 | 	int size;
36 | 	struct epoll_event *events;
37 | 	struct kevent *eventlist;
38 | };
39 | int 	co_epoll_wait( int epfd,struct co_epoll_res *events,int maxevents,int timeout );
40 | int 	co_epoll_ctl( int epfd,int op,int fd,struct epoll_event * );
41 | int 	co_epoll_create( int size );
42 | struct 	co_epoll_res *co_epoll_res_alloc( int n );
43 | void 	co_epoll_res_free( struct co_epoll_res * );
44 | 
45 | #else
46 | 
47 | #include <sys/event.h>
48 | enum EPOLL_EVENTS
49 | {
50 | 	EPOLLIN = 0X001,
51 | 	EPOLLPRI = 0X002,
52 | 	EPOLLOUT = 0X004,
53 | 
54 | 	EPOLLERR = 0X008,
55 | 	EPOLLHUP = 0X010,
56 | };
57 | #define EPOLL_CTL_ADD 1
58 | #define EPOLL_CTL_DEL 2
59 | #define EPOLL_CTL_MOD 3
60 | typedef union epoll_data
61 | {
62 | 	void *ptr;
63 | 	int fd;
64 | 	uint32_t u32;
65 | 	uint64_t u64;
66 | 
67 | } epoll_data_t;
68 | 
69 | struct epoll_event
70 | {
71 | 	uint32_t events;
72 | 	epoll_data_t data;
73 | };
74 | 
75 | struct co_epoll_res
76 | {
77 | 	int size;
78 | 	struct epoll_event *events;
79 | 	struct kevent *eventlist;
80 | };
81 | int 	co_epoll_wait( int epfd,struct co_epoll_res *events,int maxevents,int timeout );
82 | int 	co_epoll_ctl( int epfd,int op,int fd,struct epoll_event * );
83 | int 	co_epoll_create( int size );
84 | struct 	co_epoll_res *co_epoll_res_alloc( int n );
85 | void 	co_epoll_res_free( struct co_epoll_res * );
86 | 
87 | #endif
88 | #endif
89 | 
90 | 
91 | 


--------------------------------------------------------------------------------
/co_hook_sys_call.cpp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/tencent-wechat/libco/12878a93c9b345a3c175418affb214e6d5034d7e/co_hook_sys_call.cpp


--------------------------------------------------------------------------------
/co_routine.cpp:
--------------------------------------------------------------------------------
   1 | /*
   2 | * Tencent is pleased to support the open source community by making Libco available.
   3 | 
   4 | * Copyright (C) 2014 THL A29 Limited, a Tencent company. All rights reserved.
   5 | *
   6 | * Licensed under the Apache License, Version 2.0 (the "License"); 
   7 | * you may not use this file except in compliance with the License. 
   8 | * You may obtain a copy of the License at
   9 | *
  10 | *	http://www.apache.org/licenses/LICENSE-2.0
  11 | *
  12 | * Unless required by applicable law or agreed to in writing, 
  13 | * software distributed under the License is distributed on an "AS IS" BASIS, 
  14 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
  15 | * See the License for the specific language governing permissions and 
  16 | * limitations under the License.
  17 | */
  18 | 
  19 | #include "co_routine.h"
  20 | #include "co_routine_inner.h"
  21 | #include "co_epoll.h"
  22 | 
  23 | #include <string.h>
  24 | #include <stdlib.h>
  25 | #include <stdio.h>
  26 | #include <string>
  27 | #include <map>
  28 | 
  29 | #include <poll.h>
  30 | #include <sys/time.h>
  31 | #include <errno.h>
  32 | 
  33 | #include <assert.h>
  34 | 
  35 | #include <fcntl.h>
  36 | #include <sys/socket.h>
  37 | #include <netinet/in.h>
  38 | #include <arpa/inet.h>
  39 | #include <sys/syscall.h>
  40 | #include <unistd.h>
  41 | 
  42 | extern "C"
  43 | {
  44 | 	extern void coctx_swap( coctx_t *,coctx_t* ) asm("coctx_swap");
  45 | };
  46 | using namespace std;
  47 | stCoRoutine_t *GetCurrCo( stCoRoutineEnv_t *env );
  48 | struct stCoEpoll_t;
  49 | 
  50 | struct stCoRoutineEnv_t
  51 | {
  52 | 	stCoRoutine_t *pCallStack[ 128 ];
  53 | 	int iCallStackSize;
  54 | 	stCoEpoll_t *pEpoll;
  55 | 
  56 | 	//for copy stack log lastco and nextco
  57 | 	stCoRoutine_t* pending_co;
  58 | 	stCoRoutine_t* ocupy_co;
  59 | };
  60 | //int socket(int domain, int type, int protocol);
  61 | void co_log_err( const char *fmt,... )
  62 | {
  63 | }
  64 | 
  65 | 
  66 | #if defined( __LIBCO_RDTSCP__) 
  67 | static unsigned long long counter(void)
  68 | {
  69 | 	register uint32_t lo, hi;
  70 | 	register unsigned long long o;
  71 | 	__asm__ __volatile__ (
  72 | 			"rdtscp" : "=a"(lo), "=d"(hi)
  73 | 			);
  74 | 	o = hi;
  75 | 	o <<= 32;
  76 | 	return (o | lo);
  77 | 
  78 | }
  79 | static unsigned long long getCpuKhz()
  80 | {
  81 | 	FILE *fp = fopen("/proc/cpuinfo","r");
  82 | 	if(!fp) return 1;
  83 | 	char buf[4096] = {0};
  84 | 	fread(buf,1,sizeof(buf),fp);
  85 | 	fclose(fp);
  86 | 
  87 | 	char *lp = strstr(buf,"cpu MHz");
  88 | 	if(!lp) return 1;
  89 | 	lp += strlen("cpu MHz");
  90 | 	while(*lp == ' ' || *lp == '\t' || *lp == ':')
  91 | 	{
  92 | 		++lp;
  93 | 	}
  94 | 
  95 | 	double mhz = atof(lp);
  96 | 	unsigned long long u = (unsigned long long)(mhz * 1000);
  97 | 	return u;
  98 | }
  99 | #endif
 100 | 
 101 | static unsigned long long GetTickMS()
 102 | {
 103 | #if defined( __LIBCO_RDTSCP__) 
 104 | 	static uint32_t khz = getCpuKhz();
 105 | 	return counter() / khz;
 106 | #else
 107 | 	struct timeval now = { 0 };
 108 | 	gettimeofday( &now,NULL );
 109 | 	unsigned long long u = now.tv_sec;
 110 | 	u *= 1000;
 111 | 	u += now.tv_usec / 1000;
 112 | 	return u;
 113 | #endif
 114 | }
 115 | 
 116 | static pid_t GetPid()
 117 | {
 118 |     static __thread pid_t pid = 0;
 119 |     static __thread pid_t tid = 0;
 120 |     if( !pid || !tid || pid != getpid() )
 121 |     {
 122 |         pid = getpid();
 123 | #if defined( __APPLE__ )
 124 | 		tid = syscall( SYS_gettid );
 125 | 		if( -1 == (long)tid )
 126 | 		{
 127 | 			tid = pid;
 128 | 		}
 129 | #else 
 130 |         tid = syscall( __NR_gettid );
 131 | #endif
 132 | 
 133 |     }
 134 |     return tid;
 135 | 
 136 | }
 137 | /*
 138 | static pid_t GetPid()
 139 | {
 140 | 	char **p = (char**)pthread_self();
 141 | 	return p ? *(pid_t*)(p + 18) : getpid();
 142 | }
 143 | */
 144 | template <class T,class TLink>
 145 | void RemoveFromLink(T *ap)
 146 | {
 147 | 	TLink *lst = ap->pLink;
 148 | 	if(!lst) return ;
 149 | 	assert( lst->head && lst->tail );
 150 | 
 151 | 	if( ap == lst->head )
 152 | 	{
 153 | 		lst->head = ap->pNext;
 154 | 		if(lst->head)
 155 | 		{
 156 | 			lst->head->pPrev = NULL;
 157 | 		}
 158 | 	}
 159 | 	else
 160 | 	{
 161 | 		if(ap->pPrev)
 162 | 		{
 163 | 			ap->pPrev->pNext = ap->pNext;
 164 | 		}
 165 | 	}
 166 | 
 167 | 	if( ap == lst->tail )
 168 | 	{
 169 | 		lst->tail = ap->pPrev;
 170 | 		if(lst->tail)
 171 | 		{
 172 | 			lst->tail->pNext = NULL;
 173 | 		}
 174 | 	}
 175 | 	else
 176 | 	{
 177 | 		ap->pNext->pPrev = ap->pPrev;
 178 | 	}
 179 | 
 180 | 	ap->pPrev = ap->pNext = NULL;
 181 | 	ap->pLink = NULL;
 182 | }
 183 | 
 184 | template <class TNode,class TLink>
 185 | void inline AddTail(TLink*apLink,TNode *ap)
 186 | {
 187 | 	if( ap->pLink )
 188 | 	{
 189 | 		return ;
 190 | 	}
 191 | 	if(apLink->tail)
 192 | 	{
 193 | 		apLink->tail->pNext = (TNode*)ap;
 194 | 		ap->pNext = NULL;
 195 | 		ap->pPrev = apLink->tail;
 196 | 		apLink->tail = ap;
 197 | 	}
 198 | 	else
 199 | 	{
 200 | 		apLink->head = apLink->tail = ap;
 201 | 		ap->pNext = ap->pPrev = NULL;
 202 | 	}
 203 | 	ap->pLink = apLink;
 204 | }
 205 | template <class TNode,class TLink>
 206 | void inline PopHead( TLink*apLink )
 207 | {
 208 | 	if( !apLink->head ) 
 209 | 	{
 210 | 		return ;
 211 | 	}
 212 | 	TNode *lp = apLink->head;
 213 | 	if( apLink->head == apLink->tail )
 214 | 	{
 215 | 		apLink->head = apLink->tail = NULL;
 216 | 	}
 217 | 	else
 218 | 	{
 219 | 		apLink->head = apLink->head->pNext;
 220 | 	}
 221 | 
 222 | 	lp->pPrev = lp->pNext = NULL;
 223 | 	lp->pLink = NULL;
 224 | 
 225 | 	if( apLink->head )
 226 | 	{
 227 | 		apLink->head->pPrev = NULL;
 228 | 	}
 229 | }
 230 | 
 231 | template <class TNode,class TLink>
 232 | void inline Join( TLink*apLink,TLink *apOther )
 233 | {
 234 | 	//printf("apOther %p\n",apOther);
 235 | 	if( !apOther->head )
 236 | 	{
 237 | 		return ;
 238 | 	}
 239 | 	TNode *lp = apOther->head;
 240 | 	while( lp )
 241 | 	{
 242 | 		lp->pLink = apLink;
 243 | 		lp = lp->pNext;
 244 | 	}
 245 | 	lp = apOther->head;
 246 | 	if(apLink->tail)
 247 | 	{
 248 | 		apLink->tail->pNext = (TNode*)lp;
 249 | 		lp->pPrev = apLink->tail;
 250 | 		apLink->tail = apOther->tail;
 251 | 	}
 252 | 	else
 253 | 	{
 254 | 		apLink->head = apOther->head;
 255 | 		apLink->tail = apOther->tail;
 256 | 	}
 257 | 
 258 | 	apOther->head = apOther->tail = NULL;
 259 | }
 260 | 
 261 | /////////////////for copy stack //////////////////////////
 262 | stStackMem_t* co_alloc_stackmem(unsigned int stack_size)
 263 | {
 264 | 	stStackMem_t* stack_mem = (stStackMem_t*)malloc(sizeof(stStackMem_t));
 265 | 	stack_mem->ocupy_co= NULL;
 266 | 	stack_mem->stack_size = stack_size;
 267 | 	stack_mem->stack_buffer = (char*)malloc(stack_size);
 268 | 	stack_mem->stack_bp = stack_mem->stack_buffer + stack_size;
 269 | 	return stack_mem;
 270 | }
 271 | 
 272 | stShareStack_t* co_alloc_sharestack(int count, int stack_size)
 273 | {
 274 | 	stShareStack_t* share_stack = (stShareStack_t*)malloc(sizeof(stShareStack_t));
 275 | 	share_stack->alloc_idx = 0;
 276 | 	share_stack->stack_size = stack_size;
 277 | 
 278 | 	//alloc stack array
 279 | 	share_stack->count = count;
 280 | 	stStackMem_t** stack_array = (stStackMem_t**)calloc(count, sizeof(stStackMem_t*));
 281 | 	for (int i = 0; i < count; i++)
 282 | 	{
 283 | 		stack_array[i] = co_alloc_stackmem(stack_size);
 284 | 	}
 285 | 	share_stack->stack_array = stack_array;
 286 | 	return share_stack;
 287 | }
 288 | 
 289 | static stStackMem_t* co_get_stackmem(stShareStack_t* share_stack)
 290 | {
 291 | 	if (!share_stack)
 292 | 	{
 293 | 		return NULL;
 294 | 	}
 295 | 	int idx = share_stack->alloc_idx % share_stack->count;
 296 | 	share_stack->alloc_idx++;
 297 | 
 298 | 	return share_stack->stack_array[idx];
 299 | }
 300 | 
 301 | 
 302 | // ----------------------------------------------------------------------------
 303 | struct stTimeoutItemLink_t;
 304 | struct stTimeoutItem_t;
 305 | struct stCoEpoll_t
 306 | {
 307 | 	int iEpollFd;
 308 | 	static const int _EPOLL_SIZE = 1024 * 10;
 309 | 
 310 | 	struct stTimeout_t *pTimeout;
 311 | 
 312 | 	struct stTimeoutItemLink_t *pstTimeoutList;
 313 | 
 314 | 	struct stTimeoutItemLink_t *pstActiveList;
 315 | 
 316 | 	co_epoll_res *result; 
 317 | 
 318 | };
 319 | typedef void (*OnPreparePfn_t)( stTimeoutItem_t *,struct epoll_event &ev, stTimeoutItemLink_t *active );
 320 | typedef void (*OnProcessPfn_t)( stTimeoutItem_t *);
 321 | struct stTimeoutItem_t
 322 | {
 323 | 
 324 | 	enum
 325 | 	{
 326 | 		eMaxTimeout = 40 * 1000 //40s
 327 | 	};
 328 | 	stTimeoutItem_t *pPrev;
 329 | 	stTimeoutItem_t *pNext;
 330 | 	stTimeoutItemLink_t *pLink;
 331 | 
 332 | 	unsigned long long ullExpireTime;
 333 | 
 334 | 	OnPreparePfn_t pfnPrepare;
 335 | 	OnProcessPfn_t pfnProcess;
 336 | 
 337 | 	void *pArg; // routine 
 338 | 	bool bTimeout;
 339 | };
 340 | struct stTimeoutItemLink_t
 341 | {
 342 | 	stTimeoutItem_t *head;
 343 | 	stTimeoutItem_t *tail;
 344 | 
 345 | };
 346 | struct stTimeout_t
 347 | {
 348 | 	stTimeoutItemLink_t *pItems;
 349 | 	int iItemSize;
 350 | 
 351 | 	unsigned long long ullStart;
 352 | 	long long llStartIdx;
 353 | };
 354 | stTimeout_t *AllocTimeout( int iSize )
 355 | {
 356 | 	stTimeout_t *lp = (stTimeout_t*)calloc( 1,sizeof(stTimeout_t) );	
 357 | 
 358 | 	lp->iItemSize = iSize;
 359 | 	lp->pItems = (stTimeoutItemLink_t*)calloc( 1,sizeof(stTimeoutItemLink_t) * lp->iItemSize );
 360 | 
 361 | 	lp->ullStart = GetTickMS();
 362 | 	lp->llStartIdx = 0;
 363 | 
 364 | 	return lp;
 365 | }
 366 | void FreeTimeout( stTimeout_t *apTimeout )
 367 | {
 368 | 	free( apTimeout->pItems );
 369 | 	free ( apTimeout );
 370 | }
 371 | int AddTimeout( stTimeout_t *apTimeout,stTimeoutItem_t *apItem ,unsigned long long allNow )
 372 | {
 373 | 	if( apTimeout->ullStart == 0 )
 374 | 	{
 375 | 		apTimeout->ullStart = allNow;
 376 | 		apTimeout->llStartIdx = 0;
 377 | 	}
 378 | 	if( allNow < apTimeout->ullStart )
 379 | 	{
 380 | 		co_log_err("CO_ERR: AddTimeout line %d allNow %llu apTimeout->ullStart %llu",
 381 | 					__LINE__,allNow,apTimeout->ullStart);
 382 | 
 383 | 		return __LINE__;
 384 | 	}
 385 | 	if( apItem->ullExpireTime < allNow )
 386 | 	{
 387 | 		co_log_err("CO_ERR: AddTimeout line %d apItem->ullExpireTime %llu allNow %llu apTimeout->ullStart %llu",
 388 | 					__LINE__,apItem->ullExpireTime,allNow,apTimeout->ullStart);
 389 | 
 390 | 		return __LINE__;
 391 | 	}
 392 | 	int diff = apItem->ullExpireTime - apTimeout->ullStart;
 393 | 
 394 | 	if( diff >= apTimeout->iItemSize )
 395 | 	{
 396 | 		co_log_err("CO_ERR: AddTimeout line %d diff %d",
 397 | 					__LINE__,diff);
 398 | 
 399 | 		return __LINE__;
 400 | 	}
 401 | 	AddTail( apTimeout->pItems + ( apTimeout->llStartIdx + diff ) % apTimeout->iItemSize , apItem );
 402 | 
 403 | 	return 0;
 404 | }
 405 | inline void TakeAllTimeout( stTimeout_t *apTimeout,unsigned long long allNow,stTimeoutItemLink_t *apResult )
 406 | {
 407 | 	if( apTimeout->ullStart == 0 )
 408 | 	{
 409 | 		apTimeout->ullStart = allNow;
 410 | 		apTimeout->llStartIdx = 0;
 411 | 	}
 412 | 
 413 | 	if( allNow < apTimeout->ullStart )
 414 | 	{
 415 | 		return ;
 416 | 	}
 417 | 	int cnt = allNow - apTimeout->ullStart + 1;
 418 | 	if( cnt > apTimeout->iItemSize )
 419 | 	{
 420 | 		cnt = apTimeout->iItemSize;
 421 | 	}
 422 | 	if( cnt < 0 )
 423 | 	{
 424 | 		return;
 425 | 	}
 426 | 	for( int i = 0;i<cnt;i++)
 427 | 	{
 428 | 		int idx = ( apTimeout->llStartIdx + i) % apTimeout->iItemSize;
 429 | 		Join<stTimeoutItem_t,stTimeoutItemLink_t>( apResult,apTimeout->pItems + idx  );
 430 | 	}
 431 | 	apTimeout->ullStart = allNow;
 432 | 	apTimeout->llStartIdx += cnt - 1;
 433 | 
 434 | 
 435 | }
 436 | static int CoRoutineFunc( stCoRoutine_t *co,void * )
 437 | {
 438 | 	if( co->pfn )
 439 | 	{
 440 | 		co->pfn( co->arg );
 441 | 	}
 442 | 	co->cEnd = 1;
 443 | 
 444 | 	stCoRoutineEnv_t *env = co->env;
 445 | 
 446 | 	co_yield_env( env );
 447 | 
 448 | 	return 0;
 449 | }
 450 | 
 451 | 
 452 | 
 453 | struct stCoRoutine_t *co_create_env( stCoRoutineEnv_t * env, const stCoRoutineAttr_t* attr,
 454 | 		pfn_co_routine_t pfn,void *arg )
 455 | {
 456 | 
 457 | 	stCoRoutineAttr_t at;
 458 | 	if( attr )
 459 | 	{
 460 | 		memcpy( &at,attr,sizeof(at) );
 461 | 	}
 462 | 	if( at.stack_size <= 0 )
 463 | 	{
 464 | 		at.stack_size = 128 * 1024;
 465 | 	}
 466 | 	else if( at.stack_size > 1024 * 1024 * 8 )
 467 | 	{
 468 | 		at.stack_size = 1024 * 1024 * 8;
 469 | 	}
 470 | 
 471 | 	if( at.stack_size & 0xFFF ) 
 472 | 	{
 473 | 		at.stack_size &= ~0xFFF;
 474 | 		at.stack_size += 0x1000;
 475 | 	}
 476 | 
 477 | 	stCoRoutine_t *lp = (stCoRoutine_t*)malloc( sizeof(stCoRoutine_t) );
 478 | 	
 479 | 	memset( lp,0,(long)(sizeof(stCoRoutine_t))); 
 480 | 
 481 | 
 482 | 	lp->env = env;
 483 | 	lp->pfn = pfn;
 484 | 	lp->arg = arg;
 485 | 
 486 | 	stStackMem_t* stack_mem = NULL;
 487 | 	if( at.share_stack )
 488 | 	{
 489 | 		stack_mem = co_get_stackmem( at.share_stack);
 490 | 		at.stack_size = at.share_stack->stack_size;
 491 | 	}
 492 | 	else
 493 | 	{
 494 | 		stack_mem = co_alloc_stackmem(at.stack_size);
 495 | 	}
 496 | 	lp->stack_mem = stack_mem;
 497 | 
 498 | 	lp->ctx.ss_sp = stack_mem->stack_buffer;
 499 | 	lp->ctx.ss_size = at.stack_size;
 500 | 
 501 | 	lp->cStart = 0;
 502 | 	lp->cEnd = 0;
 503 | 	lp->cIsMain = 0;
 504 | 	lp->cEnableSysHook = 0;
 505 | 	lp->cIsShareStack = at.share_stack != NULL;
 506 | 
 507 | 	lp->save_size = 0;
 508 | 	lp->save_buffer = NULL;
 509 | 
 510 | 	return lp;
 511 | }
 512 | 
 513 | int co_create( stCoRoutine_t **ppco,const stCoRoutineAttr_t *attr,pfn_co_routine_t pfn,void *arg )
 514 | {
 515 | 	if( !co_get_curr_thread_env() ) 
 516 | 	{
 517 | 		co_init_curr_thread_env();
 518 | 	}
 519 | 	stCoRoutine_t *co = co_create_env( co_get_curr_thread_env(), attr, pfn,arg );
 520 | 	*ppco = co;
 521 | 	return 0;
 522 | }
 523 | void co_free( stCoRoutine_t *co )
 524 | {
 525 | 	free( co );
 526 | }
 527 | void co_release( stCoRoutine_t *co )
 528 | {
 529 | 	if( co->cEnd )
 530 | 	{
 531 | 		free( co );
 532 | 	}
 533 | }
 534 | 
 535 | void co_swap(stCoRoutine_t* curr, stCoRoutine_t* pending_co);
 536 | 
 537 | void co_resume( stCoRoutine_t *co )
 538 | {
 539 | 	stCoRoutineEnv_t *env = co->env;
 540 | 	stCoRoutine_t *lpCurrRoutine = env->pCallStack[ env->iCallStackSize - 1 ];
 541 | 	if( !co->cStart )
 542 | 	{
 543 | 		coctx_make( &co->ctx,(coctx_pfn_t)CoRoutineFunc,co,0 );
 544 | 		co->cStart = 1;
 545 | 	}
 546 | 	env->pCallStack[ env->iCallStackSize++ ] = co;
 547 | 	co_swap( lpCurrRoutine, co );
 548 | 
 549 | 
 550 | }
 551 | void co_yield_env( stCoRoutineEnv_t *env )
 552 | {
 553 | 	
 554 | 	stCoRoutine_t *last = env->pCallStack[ env->iCallStackSize - 2 ];
 555 | 	stCoRoutine_t *curr = env->pCallStack[ env->iCallStackSize - 1 ];
 556 | 
 557 | 	env->iCallStackSize--;
 558 | 
 559 | 	co_swap( curr, last);
 560 | }
 561 | 
 562 | void co_yield_ct()
 563 | {
 564 | 
 565 | 	co_yield_env( co_get_curr_thread_env() );
 566 | }
 567 | void co_yield( stCoRoutine_t *co )
 568 | {
 569 | 	co_yield_env( co->env );
 570 | }
 571 | 
 572 | void save_stack_buffer(stCoRoutine_t* ocupy_co)
 573 | {
 574 | 	///copy out
 575 | 	stStackMem_t* stack_mem = ocupy_co->stack_mem;
 576 | 	int len = stack_mem->stack_bp - ocupy_co->stack_sp;
 577 | 
 578 | 	if (ocupy_co->save_buffer)
 579 | 	{
 580 | 		free(ocupy_co->save_buffer), ocupy_co->save_buffer = NULL;
 581 | 	}
 582 | 
 583 | 	ocupy_co->save_buffer = (char*)malloc(len); //malloc buf;
 584 | 	ocupy_co->save_size = len;
 585 | 
 586 | 	memcpy(ocupy_co->save_buffer, ocupy_co->stack_sp, len);
 587 | }
 588 | 
 589 | void co_swap(stCoRoutine_t* curr, stCoRoutine_t* pending_co)
 590 | {
 591 |  	stCoRoutineEnv_t* env = co_get_curr_thread_env();
 592 | 
 593 | 	//get curr stack sp
 594 | 	char c;
 595 | 	curr->stack_sp= &c;
 596 | 
 597 | 	if (!pending_co->cIsShareStack)
 598 | 	{
 599 | 		env->pending_co = NULL;
 600 | 		env->ocupy_co = NULL;
 601 | 	}
 602 | 	else 
 603 | 	{
 604 | 		env->pending_co = pending_co;
 605 | 		//get last occupy co on the same stack mem
 606 | 		stCoRoutine_t* ocupy_co = pending_co->stack_mem->ocupy_co;
 607 | 		//set pending co to ocupy thest stack mem;
 608 | 		pending_co->stack_mem->ocupy_co = pending_co;
 609 | 
 610 | 		env->ocupy_co = ocupy_co;
 611 | 		if (ocupy_co && ocupy_co != pending_co)
 612 | 		{
 613 | 			save_stack_buffer(ocupy_co);
 614 | 		}
 615 | 	}
 616 | 
 617 | 	//swap context
 618 | 	coctx_swap(&(curr->ctx),&(pending_co->ctx) );
 619 | 
 620 | 	//stack buffer may be overwrite, so get again;
 621 | 	stCoRoutineEnv_t* curr_env = co_get_curr_thread_env();
 622 | 	stCoRoutine_t* update_ocupy_co =  curr_env->ocupy_co;
 623 | 	stCoRoutine_t* update_pending_co = curr_env->pending_co;
 624 | 	
 625 | 	if (update_ocupy_co && update_pending_co && update_ocupy_co != update_pending_co)
 626 | 	{
 627 | 		//resume stack buffer
 628 | 		if (update_pending_co->save_buffer && update_pending_co->save_size > 0)
 629 | 		{
 630 | 			memcpy(update_pending_co->stack_sp, update_pending_co->save_buffer, update_pending_co->save_size);
 631 | 		}
 632 | 	}
 633 | }
 634 | 
 635 | 
 636 | 
 637 | //int poll(struct pollfd fds[], nfds_t nfds, int timeout);
 638 | // { fd,events,revents }
 639 | struct stPollItem_t ;
 640 | struct stPoll_t : public stTimeoutItem_t 
 641 | {
 642 | 	struct pollfd *fds;
 643 | 	nfds_t nfds; // typedef unsigned long int nfds_t;
 644 | 
 645 | 	stPollItem_t *pPollItems;
 646 | 
 647 | 	int iAllEventDetach;
 648 | 
 649 | 	int iEpollFd;
 650 | 
 651 | 	int iRaiseCnt;
 652 | 
 653 | 
 654 | };
 655 | struct stPollItem_t : public stTimeoutItem_t
 656 | {
 657 | 	struct pollfd *pSelf;
 658 | 	stPoll_t *pPoll;
 659 | 
 660 | 	struct epoll_event stEvent;
 661 | };
 662 | /*
 663 |  *   EPOLLPRI 		POLLPRI    // There is urgent data to read.  
 664 |  *   EPOLLMSG 		POLLMSG
 665 |  *
 666 |  *   				POLLREMOVE
 667 |  *   				POLLRDHUP
 668 |  *   				POLLNVAL
 669 |  *
 670 |  * */
 671 | static uint32_t PollEvent2Epoll( short events )
 672 | {
 673 | 	uint32_t e = 0;	
 674 | 	if( events & POLLIN ) 	e |= EPOLLIN;
 675 | 	if( events & POLLOUT )  e |= EPOLLOUT;
 676 | 	if( events & POLLHUP ) 	e |= EPOLLHUP;
 677 | 	if( events & POLLERR )	e |= EPOLLERR;
 678 | 	if( events & POLLRDNORM ) e |= EPOLLRDNORM;
 679 | 	if( events & POLLWRNORM ) e |= EPOLLWRNORM;
 680 | 	return e;
 681 | }
 682 | static short EpollEvent2Poll( uint32_t events )
 683 | {
 684 | 	short e = 0;	
 685 | 	if( events & EPOLLIN ) 	e |= POLLIN;
 686 | 	if( events & EPOLLOUT ) e |= POLLOUT;
 687 | 	if( events & EPOLLHUP ) e |= POLLHUP;
 688 | 	if( events & EPOLLERR ) e |= POLLERR;
 689 | 	if( events & EPOLLRDNORM ) e |= POLLRDNORM;
 690 | 	if( events & EPOLLWRNORM ) e |= POLLWRNORM;
 691 | 	return e;
 692 | }
 693 | 
 694 | static stCoRoutineEnv_t* g_arrCoEnvPerThread[ 204800 ] = { 0 };
 695 | void co_init_curr_thread_env()
 696 | {
 697 | 	pid_t pid = GetPid();	
 698 | 	g_arrCoEnvPerThread[ pid ] = (stCoRoutineEnv_t*)calloc( 1,sizeof(stCoRoutineEnv_t) );
 699 | 	stCoRoutineEnv_t *env = g_arrCoEnvPerThread[ pid ];
 700 | 
 701 | 	env->iCallStackSize = 0;
 702 | 	struct stCoRoutine_t *self = co_create_env( env, NULL, NULL,NULL );
 703 | 	self->cIsMain = 1;
 704 | 
 705 | 	env->pending_co = NULL;
 706 | 	env->ocupy_co = NULL;
 707 | 
 708 | 	coctx_init( &self->ctx );
 709 | 
 710 | 	env->pCallStack[ env->iCallStackSize++ ] = self;
 711 | 
 712 | 	stCoEpoll_t *ev = AllocEpoll();
 713 | 	SetEpoll( env,ev );
 714 | }
 715 | stCoRoutineEnv_t *co_get_curr_thread_env()
 716 | {
 717 | 	return g_arrCoEnvPerThread[ GetPid() ];
 718 | }
 719 | 
 720 | void OnPollProcessEvent( stTimeoutItem_t * ap )
 721 | {
 722 | 	stCoRoutine_t *co = (stCoRoutine_t*)ap->pArg;
 723 | 	co_resume( co );
 724 | }
 725 | 
 726 | void OnPollPreparePfn( stTimeoutItem_t * ap,struct epoll_event &e,stTimeoutItemLink_t *active )
 727 | {
 728 | 	stPollItem_t *lp = (stPollItem_t *)ap;
 729 | 	lp->pSelf->revents = EpollEvent2Poll( e.events );
 730 | 
 731 | 
 732 | 	stPoll_t *pPoll = lp->pPoll;
 733 | 	pPoll->iRaiseCnt++;
 734 | 
 735 | 	if( !pPoll->iAllEventDetach )
 736 | 	{
 737 | 		pPoll->iAllEventDetach = 1;
 738 | 
 739 | 		RemoveFromLink<stTimeoutItem_t,stTimeoutItemLink_t>( pPoll );
 740 | 
 741 | 		AddTail( active,pPoll );
 742 | 
 743 | 	}
 744 | }
 745 | 
 746 | 
 747 | void co_eventloop( stCoEpoll_t *ctx,pfn_co_eventloop_t pfn,void *arg )
 748 | {
 749 | 	if( !ctx->result )
 750 | 	{
 751 | 		ctx->result =  co_epoll_res_alloc( stCoEpoll_t::_EPOLL_SIZE );
 752 | 	}
 753 | 	co_epoll_res *result = ctx->result;
 754 | 
 755 | 
 756 | 	for(;;)
 757 | 	{
 758 | 		int ret = co_epoll_wait( ctx->iEpollFd,result,stCoEpoll_t::_EPOLL_SIZE, 1 );
 759 | 
 760 | 		stTimeoutItemLink_t *active = (ctx->pstActiveList);
 761 | 		stTimeoutItemLink_t *timeout = (ctx->pstTimeoutList);
 762 | 
 763 | 		memset( timeout,0,sizeof(stTimeoutItemLink_t) );
 764 | 
 765 | 		for(int i=0;i<ret;i++)
 766 | 		{
 767 | 			stTimeoutItem_t *item = (stTimeoutItem_t*)result->events[i].data.ptr;
 768 | 			if( item->pfnPrepare )
 769 | 			{
 770 | 				item->pfnPrepare( item,result->events[i],active );
 771 | 			}
 772 | 			else
 773 | 			{
 774 | 				AddTail( active,item );
 775 | 			}
 776 | 		}
 777 | 
 778 | 
 779 | 		unsigned long long now = GetTickMS();
 780 | 		TakeAllTimeout( ctx->pTimeout,now,timeout );
 781 | 
 782 | 		stTimeoutItem_t *lp = timeout->head;
 783 | 		while( lp )
 784 | 		{
 785 | 			//printf("raise timeout %p\n",lp);
 786 | 			lp->bTimeout = true;
 787 | 			lp = lp->pNext;
 788 | 		}
 789 | 
 790 | 		Join<stTimeoutItem_t,stTimeoutItemLink_t>( active,timeout );
 791 | 
 792 | 		lp = active->head;
 793 | 		while( lp )
 794 | 		{
 795 | 
 796 | 			PopHead<stTimeoutItem_t,stTimeoutItemLink_t>( active );
 797 | 			if( lp->pfnProcess )
 798 | 			{
 799 | 				lp->pfnProcess( lp );
 800 | 			}
 801 | 
 802 | 			lp = active->head;
 803 | 		}
 804 | 		if( pfn )
 805 | 		{
 806 | 			if( -1 == pfn( arg ) )
 807 | 			{
 808 | 				break;
 809 | 			}
 810 | 		}
 811 | 
 812 | 	}
 813 | }
 814 | void OnCoroutineEvent( stTimeoutItem_t * ap )
 815 | {
 816 | 	stCoRoutine_t *co = (stCoRoutine_t*)ap->pArg;
 817 | 	co_resume( co );
 818 | }
 819 | 
 820 | 
 821 | stCoEpoll_t *AllocEpoll()
 822 | {
 823 | 	stCoEpoll_t *ctx = (stCoEpoll_t*)calloc( 1,sizeof(stCoEpoll_t) );
 824 | 
 825 | 	ctx->iEpollFd = co_epoll_create( stCoEpoll_t::_EPOLL_SIZE );
 826 | 	ctx->pTimeout = AllocTimeout( 60 * 1000 );
 827 | 	
 828 | 	ctx->pstActiveList = (stTimeoutItemLink_t*)calloc( 1,sizeof(stTimeoutItemLink_t) );
 829 | 	ctx->pstTimeoutList = (stTimeoutItemLink_t*)calloc( 1,sizeof(stTimeoutItemLink_t) );
 830 | 
 831 | 
 832 | 	return ctx;
 833 | }
 834 | 
 835 | void FreeEpoll( stCoEpoll_t *ctx )
 836 | {
 837 | 	if( ctx )
 838 | 	{
 839 | 		free( ctx->pstActiveList );
 840 | 		free( ctx->pstTimeoutList );
 841 | 		FreeTimeout( ctx->pTimeout );
 842 | 		co_epoll_res_free( ctx->result );
 843 | 	}
 844 | 	free( ctx );
 845 | }
 846 | 
 847 | stCoRoutine_t *GetCurrCo( stCoRoutineEnv_t *env )
 848 | {
 849 | 	return env->pCallStack[ env->iCallStackSize - 1 ];
 850 | }
 851 | stCoRoutine_t *GetCurrThreadCo( )
 852 | {
 853 | 	stCoRoutineEnv_t *env = co_get_curr_thread_env();
 854 | 	if( !env ) return 0;
 855 | 	return GetCurrCo(env);
 856 | }
 857 | 
 858 | 
 859 | 
 860 | typedef int (*poll_pfn_t)(struct pollfd fds[], nfds_t nfds, int timeout);
 861 | int co_poll_inner( stCoEpoll_t *ctx,struct pollfd fds[], nfds_t nfds, int timeout, poll_pfn_t pollfunc)
 862 | {
 863 | 	
 864 | 	if( timeout > stTimeoutItem_t::eMaxTimeout )
 865 | 	{
 866 | 		timeout = stTimeoutItem_t::eMaxTimeout;
 867 | 	}
 868 | 	int epfd = ctx->iEpollFd;
 869 | 	stCoRoutine_t* self = co_self();
 870 | 
 871 | 	//1.struct change
 872 | 	stPoll_t& arg = *((stPoll_t*)malloc(sizeof(stPoll_t)));
 873 | 	memset( &arg,0,sizeof(arg) );
 874 | 
 875 | 	arg.iEpollFd = epfd;
 876 | 	arg.fds = (pollfd*)calloc(nfds, sizeof(pollfd));
 877 | 	arg.nfds = nfds;
 878 | 
 879 | 	stPollItem_t arr[2];
 880 | 	if( nfds < sizeof(arr) / sizeof(arr[0]) && !self->cIsShareStack)
 881 | 	{
 882 | 		arg.pPollItems = arr;
 883 | 	}	
 884 | 	else
 885 | 	{
 886 | 		arg.pPollItems = (stPollItem_t*)malloc( nfds * sizeof( stPollItem_t ) );
 887 | 	}
 888 | 	memset( arg.pPollItems,0,nfds * sizeof(stPollItem_t) );
 889 | 
 890 | 	arg.pfnProcess = OnPollProcessEvent;
 891 | 	arg.pArg = GetCurrCo( co_get_curr_thread_env() );
 892 | 	
 893 | 	
 894 | 	//2. add epoll
 895 | 	for(nfds_t i=0;i<nfds;i++)
 896 | 	{
 897 | 		arg.pPollItems[i].pSelf = arg.fds + i;
 898 | 		arg.pPollItems[i].pPoll = &arg;
 899 | 
 900 | 		arg.pPollItems[i].pfnPrepare = OnPollPreparePfn;
 901 | 		struct epoll_event &ev = arg.pPollItems[i].stEvent;
 902 | 
 903 | 		if( fds[i].fd > -1 )
 904 | 		{
 905 | 			ev.data.ptr = arg.pPollItems + i;
 906 | 			ev.events = PollEvent2Epoll( fds[i].events );
 907 | 
 908 | 			int ret = co_epoll_ctl( epfd,EPOLL_CTL_ADD, fds[i].fd, &ev );
 909 | 			if (ret < 0 && errno == EPERM && nfds == 1 && pollfunc != NULL)
 910 | 			{
 911 | 				if( arg.pPollItems != arr )
 912 | 				{
 913 | 					free( arg.pPollItems );
 914 | 					arg.pPollItems = NULL;
 915 | 				}
 916 | 				free(arg.fds);
 917 | 				free(&arg);
 918 | 				return pollfunc(fds, nfds, timeout);
 919 | 			}
 920 | 		}
 921 | 		//if fail,the timeout would work
 922 | 	}
 923 | 
 924 | 	//3.add timeout
 925 | 
 926 | 	unsigned long long now = GetTickMS();
 927 | 	arg.ullExpireTime = now + timeout;
 928 | 	int ret = AddTimeout( ctx->pTimeout,&arg,now );
 929 | 	if( ret != 0 )
 930 | 	{
 931 | 		co_log_err("CO_ERR: AddTimeout ret %d now %lld timeout %d arg.ullExpireTime %lld",
 932 | 				ret,now,timeout,arg.ullExpireTime);
 933 | 		errno = EINVAL;
 934 | 
 935 | 		if( arg.pPollItems != arr )
 936 | 		{
 937 | 			free( arg.pPollItems );
 938 | 			arg.pPollItems = NULL;
 939 | 		}
 940 | 		free(arg.fds);
 941 | 		free(&arg);
 942 | 
 943 | 		return -__LINE__;
 944 | 	}
 945 | 
 946 | 	co_yield_env( co_get_curr_thread_env() );
 947 | 
 948 | 	RemoveFromLink<stTimeoutItem_t,stTimeoutItemLink_t>( &arg );
 949 | 	for(nfds_t i = 0;i < nfds;i++)
 950 | 	{
 951 | 		int fd = fds[i].fd;
 952 | 		if( fd > -1 )
 953 | 		{
 954 | 			co_epoll_ctl( epfd,EPOLL_CTL_DEL,fd,&arg.pPollItems[i].stEvent );
 955 | 		}
 956 | 		fds[i].revents = arg.fds[i].revents;
 957 | 	}
 958 | 
 959 | 
 960 | 	int iRaiseCnt = arg.iRaiseCnt;
 961 | 	if( arg.pPollItems != arr )
 962 | 	{
 963 | 		free( arg.pPollItems );
 964 | 		arg.pPollItems = NULL;
 965 | 	}
 966 | 
 967 | 	free(arg.fds);
 968 | 	free(&arg);
 969 | 
 970 | 	return iRaiseCnt;
 971 | }
 972 | 
 973 | int	co_poll( stCoEpoll_t *ctx,struct pollfd fds[], nfds_t nfds, int timeout_ms )
 974 | {
 975 | 	return co_poll_inner(ctx, fds, nfds, timeout_ms, NULL);
 976 | }
 977 | 
 978 | void SetEpoll( stCoRoutineEnv_t *env,stCoEpoll_t *ev )
 979 | {
 980 | 	env->pEpoll = ev;
 981 | }
 982 | stCoEpoll_t *co_get_epoll_ct()
 983 | {
 984 | 	if( !co_get_curr_thread_env() )
 985 | 	{
 986 | 		co_init_curr_thread_env();
 987 | 	}
 988 | 	return co_get_curr_thread_env()->pEpoll;
 989 | }
 990 | struct stHookPThreadSpec_t
 991 | {
 992 | 	stCoRoutine_t *co;
 993 | 	void *value;
 994 | 
 995 | 	enum 
 996 | 	{
 997 | 		size = 1024
 998 | 	};
 999 | };
1000 | void *co_getspecific(pthread_key_t key)
1001 | {
1002 | 	stCoRoutine_t *co = GetCurrThreadCo();
1003 | 	if( !co || co->cIsMain )
1004 | 	{
1005 | 		return pthread_getspecific( key );
1006 | 	}
1007 | 	return co->aSpec[ key ].value;
1008 | }
1009 | int co_setspecific(pthread_key_t key, const void *value)
1010 | {
1011 | 	stCoRoutine_t *co = GetCurrThreadCo();
1012 | 	if( !co || co->cIsMain )
1013 | 	{
1014 | 		return pthread_setspecific( key,value );
1015 | 	}
1016 | 	co->aSpec[ key ].value = (void*)value;
1017 | 	return 0;
1018 | }
1019 | 
1020 | 
1021 | 
1022 | void co_disable_hook_sys()
1023 | {
1024 | 	stCoRoutine_t *co = GetCurrThreadCo();
1025 | 	if( co )
1026 | 	{
1027 | 		co->cEnableSysHook = 0;
1028 | 	}
1029 | }
1030 | bool co_is_enable_sys_hook()
1031 | {
1032 | 	stCoRoutine_t *co = GetCurrThreadCo();
1033 | 	return ( co && co->cEnableSysHook );
1034 | }
1035 | 
1036 | stCoRoutine_t *co_self()
1037 | {
1038 | 	return GetCurrThreadCo();
1039 | }
1040 | 
1041 | //co cond
1042 | struct stCoCond_t;
1043 | struct stCoCondItem_t 
1044 | {
1045 | 	stCoCondItem_t *pPrev;
1046 | 	stCoCondItem_t *pNext;
1047 | 	stCoCond_t *pLink;
1048 | 
1049 | 	stTimeoutItem_t timeout;
1050 | };
1051 | struct stCoCond_t
1052 | {
1053 | 	stCoCondItem_t *head;
1054 | 	stCoCondItem_t *tail;
1055 | };
1056 | static void OnSignalProcessEvent( stTimeoutItem_t * ap )
1057 | {
1058 | 	stCoRoutine_t *co = (stCoRoutine_t*)ap->pArg;
1059 | 	co_resume( co );
1060 | }
1061 | 
1062 | stCoCondItem_t *co_cond_pop( stCoCond_t *link );
1063 | int co_cond_signal( stCoCond_t *si )
1064 | {
1065 | 	stCoCondItem_t * sp = co_cond_pop( si );
1066 | 	if( !sp ) 
1067 | 	{
1068 | 		return 0;
1069 | 	}
1070 | 	RemoveFromLink<stTimeoutItem_t,stTimeoutItemLink_t>( &sp->timeout );
1071 | 
1072 | 	AddTail( co_get_curr_thread_env()->pEpoll->pstActiveList,&sp->timeout );
1073 | 
1074 | 	return 0;
1075 | }
1076 | int co_cond_broadcast( stCoCond_t *si )
1077 | {
1078 | 	for(;;)
1079 | 	{
1080 | 		stCoCondItem_t * sp = co_cond_pop( si );
1081 | 		if( !sp ) return 0;
1082 | 
1083 | 		RemoveFromLink<stTimeoutItem_t,stTimeoutItemLink_t>( &sp->timeout );
1084 | 
1085 | 		AddTail( co_get_curr_thread_env()->pEpoll->pstActiveList,&sp->timeout );
1086 | 	}
1087 | 
1088 | 	return 0;
1089 | }
1090 | 
1091 | 
1092 | int co_cond_timedwait( stCoCond_t *link,int ms )
1093 | {
1094 | 	stCoCondItem_t* psi = (stCoCondItem_t*)calloc(1, sizeof(stCoCondItem_t));
1095 | 	psi->timeout.pArg = GetCurrThreadCo();
1096 | 	psi->timeout.pfnProcess = OnSignalProcessEvent;
1097 | 
1098 | 	if( ms > 0 )
1099 | 	{
1100 | 		unsigned long long now = GetTickMS();
1101 | 		psi->timeout.ullExpireTime = now + ms;
1102 | 
1103 | 		int ret = AddTimeout( co_get_curr_thread_env()->pEpoll->pTimeout,&psi->timeout,now );
1104 | 		if( ret != 0 )
1105 | 		{
1106 | 			free(psi);
1107 | 			return ret;
1108 | 		}
1109 | 	}
1110 | 	AddTail( link, psi);
1111 | 
1112 | 	co_yield_ct();
1113 | 
1114 | 
1115 | 	RemoveFromLink<stCoCondItem_t,stCoCond_t>( psi );
1116 | 	free(psi);
1117 | 
1118 | 	return 0;
1119 | }
1120 | stCoCond_t *co_cond_alloc()
1121 | {
1122 | 	return (stCoCond_t*)calloc( 1,sizeof(stCoCond_t) );
1123 | }
1124 | int co_cond_free( stCoCond_t * cc )
1125 | {
1126 | 	free( cc );
1127 | 	return 0;
1128 | }
1129 | 
1130 | 
1131 | stCoCondItem_t *co_cond_pop( stCoCond_t *link )
1132 | {
1133 | 	stCoCondItem_t *p = link->head;
1134 | 	if( p )
1135 | 	{
1136 | 		PopHead<stCoCondItem_t,stCoCond_t>( link );
1137 | 	}
1138 | 	return p;
1139 | }
1140 | 
1141 | 
1142 | 


--------------------------------------------------------------------------------
/co_routine.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | * Tencent is pleased to support the open source community by making Libco available.
 3 | 
 4 | * Copyright (C) 2014 THL A29 Limited, a Tencent company. All rights reserved.
 5 | *
 6 | * Licensed under the Apache License, Version 2.0 (the "License"); 
 7 | * you may not use this file except in compliance with the License. 
 8 | * You may obtain a copy of the License at
 9 | *
10 | *	http://www.apache.org/licenses/LICENSE-2.0
11 | *
12 | * Unless required by applicable law or agreed to in writing, 
13 | * software distributed under the License is distributed on an "AS IS" BASIS, 
14 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
15 | * See the License for the specific language governing permissions and 
16 | * limitations under the License.
17 | */
18 | 
19 | #ifndef __CO_ROUTINE_H__
20 | #define __CO_ROUTINE_H__
21 | 
22 | #include <stdint.h>
23 | #include <sys/poll.h>
24 | #include <pthread.h>
25 | 
26 | //1.struct
27 | 
28 | struct stCoRoutine_t;
29 | struct stShareStack_t;
30 | 
31 | struct stCoRoutineAttr_t
32 | {
33 | 	int stack_size;
34 | 	stShareStack_t*  share_stack;
35 | 	stCoRoutineAttr_t()
36 | 	{
37 | 		stack_size = 128 * 1024;
38 | 		share_stack = NULL;
39 | 	}
40 | }__attribute__ ((packed));
41 | 
42 | struct stCoEpoll_t;
43 | typedef int (*pfn_co_eventloop_t)(void *);
44 | typedef void *(*pfn_co_routine_t)( void * );
45 | 
46 | //2.co_routine
47 | 
48 | int 	co_create( stCoRoutine_t **co,const stCoRoutineAttr_t *attr,void *(*routine)(void*),void *arg );
49 | void    co_resume( stCoRoutine_t *co );
50 | void    co_yield( stCoRoutine_t *co );
51 | void    co_yield_ct(); //ct = current thread
52 | void    co_release( stCoRoutine_t *co );
53 | 
54 | stCoRoutine_t *co_self();
55 | 
56 | int		co_poll( stCoEpoll_t *ctx,struct pollfd fds[], nfds_t nfds, int timeout_ms );
57 | void 	co_eventloop( stCoEpoll_t *ctx,pfn_co_eventloop_t pfn,void *arg );
58 | 
59 | //3.specific
60 | 
61 | int 	co_setspecific( pthread_key_t key, const void *value );
62 | void *	co_getspecific( pthread_key_t key );
63 | 
64 | //4.event
65 | 
66 | stCoEpoll_t * 	co_get_epoll_ct(); //ct = current thread
67 | 
68 | //5.hook syscall ( poll/read/write/recv/send/recvfrom/sendto )
69 | 
70 | void 	co_enable_hook_sys();  
71 | void 	co_disable_hook_sys();  
72 | bool 	co_is_enable_sys_hook();
73 | 
74 | //6.sync
75 | struct stCoCond_t;
76 | 
77 | stCoCond_t *co_cond_alloc();
78 | int co_cond_free( stCoCond_t * cc );
79 | 
80 | int co_cond_signal( stCoCond_t * );
81 | int co_cond_broadcast( stCoCond_t * );
82 | int co_cond_timedwait( stCoCond_t *,int timeout_ms );
83 | 
84 | //7.share stack
85 | stShareStack_t* co_alloc_sharestack(int iCount, int iStackSize);
86 | 
87 | //8.init envlist for hook get/set env
88 | void co_set_env_list( const char *name[],size_t cnt);
89 | 
90 | void co_log_err( const char *fmt,... );
91 | #endif
92 | 
93 | 


--------------------------------------------------------------------------------
/co_routine_inner.h:
--------------------------------------------------------------------------------
  1 | /*
  2 | * Tencent is pleased to support the open source community by making Libco available.
  3 | 
  4 | * Copyright (C) 2014 THL A29 Limited, a Tencent company. All rights reserved.
  5 | *
  6 | * Licensed under the Apache License, Version 2.0 (the "License"); 
  7 | * you may not use this file except in compliance with the License. 
  8 | * You may obtain a copy of the License at
  9 | *
 10 | *	http://www.apache.org/licenses/LICENSE-2.0
 11 | *
 12 | * Unless required by applicable law or agreed to in writing, 
 13 | * software distributed under the License is distributed on an "AS IS" BASIS, 
 14 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
 15 | * See the License for the specific language governing permissions and 
 16 | * limitations under the License.
 17 | */
 18 | 
 19 | 
 20 | #ifndef __CO_ROUTINE_INNER_H__
 21 | 
 22 | #include "co_routine.h"
 23 | #include "coctx.h"
 24 | struct stCoRoutineEnv_t;
 25 | struct stCoSpec_t
 26 | {
 27 | 	void *value;
 28 | };
 29 | 
 30 | struct stStackMem_t
 31 | {
 32 | 	stCoRoutine_t* ocupy_co;
 33 | 	int stack_size;
 34 | 	char* stack_bp; //stack_buffer + stack_size
 35 | 	char* stack_buffer;
 36 | 
 37 | };
 38 | 
 39 | struct stShareStack_t
 40 | {
 41 | 	unsigned int alloc_idx;
 42 | 	int stack_size;
 43 | 	int count;
 44 | 	stStackMem_t** stack_array;
 45 | };
 46 | 
 47 | 
 48 | 
 49 | struct stCoRoutine_t
 50 | {
 51 | 	stCoRoutineEnv_t *env;
 52 | 	pfn_co_routine_t pfn;
 53 | 	void *arg;
 54 | 	coctx_t ctx;
 55 | 
 56 | 	char cStart;
 57 | 	char cEnd;
 58 | 	char cIsMain;
 59 | 	char cEnableSysHook;
 60 | 	char cIsShareStack;
 61 | 
 62 | 	void *pvEnv;
 63 | 
 64 | 	//char sRunStack[ 1024 * 128 ];
 65 | 	stStackMem_t* stack_mem;
 66 | 
 67 | 
 68 | 	//save satck buffer while confilct on same stack_buffer;
 69 | 	char* stack_sp; 
 70 | 	unsigned int save_size;
 71 | 	char* save_buffer;
 72 | 
 73 | 	stCoSpec_t aSpec[1024];
 74 | 
 75 | };
 76 | 
 77 | 
 78 | 
 79 | //1.env
 80 | void 				co_init_curr_thread_env();
 81 | stCoRoutineEnv_t *	co_get_curr_thread_env();
 82 | 
 83 | //2.coroutine
 84 | void    co_free( stCoRoutine_t * co );
 85 | void    co_yield_env(  stCoRoutineEnv_t *env );
 86 | 
 87 | //3.func
 88 | 
 89 | 
 90 | 
 91 | //-----------------------------------------------------------------------------------------------
 92 | 
 93 | struct stTimeout_t;
 94 | struct stTimeoutItem_t ;
 95 | 
 96 | stTimeout_t *AllocTimeout( int iSize );
 97 | void 	FreeTimeout( stTimeout_t *apTimeout );
 98 | int  	AddTimeout( stTimeout_t *apTimeout,stTimeoutItem_t *apItem ,uint64_t allNow );
 99 | 
100 | struct stCoEpoll_t;
101 | stCoEpoll_t * AllocEpoll();
102 | void 		FreeEpoll( stCoEpoll_t *ctx );
103 | 
104 | stCoRoutine_t *		GetCurrThreadCo();
105 | void 				SetEpoll( stCoRoutineEnv_t *env,stCoEpoll_t *ev );
106 | 
107 | typedef void (*pfnCoRoutineFunc_t)();
108 | 
109 | #endif
110 | 
111 | #define __CO_ROUTINE_INNER_H__
112 | 


--------------------------------------------------------------------------------
/co_routine_specific.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | * Tencent is pleased to support the open source community by making Libco available.
 3 | 
 4 | * Copyright (C) 2014 THL A29 Limited, a Tencent company. All rights reserved.
 5 | *
 6 | * Licensed under the Apache License, Version 2.0 (the "License"); 
 7 | * you may not use this file except in compliance with the License. 
 8 | * You may obtain a copy of the License at
 9 | *
10 | *	http://www.apache.org/licenses/LICENSE-2.0
11 | *
12 | * Unless required by applicable law or agreed to in writing, 
13 | * software distributed under the License is distributed on an "AS IS" BASIS, 
14 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
15 | * See the License for the specific language governing permissions and 
16 | * limitations under the License.
17 | */
18 | 
19 | #pragma once
20 | #include <pthread.h>
21 | #include <stdlib.h>
22 | 
23 | /*
24 | invoke only once in the whole program
25 | CoRoutineSetSpecificCallBack(CoRoutineGetSpecificFunc_t pfnGet,CoRoutineSetSpecificFunc_t pfnSet)
26 | 
27 | struct MyData_t
28 | {
29 | 	int iValue;
30 | 	char szValue[100];
31 | };
32 | CO_ROUTINE_SPECIFIC( MyData_t,__routine );
33 | 
34 | int main()
35 | {
36 | 	CoRoutineSetSpecificCallBack( co_getspecific,co_setspecific );
37 | 
38 | 	__routine->iValue = 10;
39 | 	strcpy( __routine->szValue,"hello world" );
40 | 
41 | 	return 0;
42 | }
43 | */
44 | extern int 	co_setspecific( pthread_key_t key, const void *value );
45 | extern void *	co_getspecific( pthread_key_t key );
46 | 
47 | #define CO_ROUTINE_SPECIFIC( name,y ) \
48 | \
49 | static pthread_once_t _routine_once_##name = PTHREAD_ONCE_INIT; \
50 | static pthread_key_t _routine_key_##name;\
51 | static int _routine_init_##name = 0;\
52 | static void _routine_make_key_##name() \
53 | {\
54 |  	(void) pthread_key_create(&_routine_key_##name, NULL); \
55 | }\
56 | template <class T>\
57 | class clsRoutineData_routine_##name\
58 | {\
59 | public:\
60 | 	inline T *operator->()\
61 | 	{\
62 | 		if( !_routine_init_##name ) \
63 | 		{\
64 | 			pthread_once( &_routine_once_##name,_routine_make_key_##name );\
65 | 			_routine_init_##name = 1;\
66 | 		}\
67 | 		T* p = (T*)co_getspecific( _routine_key_##name );\
68 | 		if( !p )\
69 | 		{\
70 | 			p = (T*)calloc(1,sizeof( T ));\
71 | 			int ret = co_setspecific( _routine_key_##name,p) ;\
72 |             if ( ret )\
73 |             {\
74 |                 if ( p )\
75 |                 {\
76 |                     free(p);\
77 |                     p = NULL;\
78 |                 }\
79 |             }\
80 | 		}\
81 | 		return p;\
82 | 	}\
83 | };\
84 | \
85 | static clsRoutineData_routine_##name<name> y;
86 | 
87 | 


--------------------------------------------------------------------------------
/coctx.cpp:
--------------------------------------------------------------------------------
  1 | /*
  2 | * Tencent is pleased to support the open source community by making Libco available.
  3 | 
  4 | * Copyright (C) 2014 THL A29 Limited, a Tencent company. All rights reserved.
  5 | *
  6 | * Licensed under the Apache License, Version 2.0 (the "License"); 
  7 | * you may not use this file except in compliance with the License. 
  8 | * You may obtain a copy of the License at
  9 | *
 10 | *	http://www.apache.org/licenses/LICENSE-2.0
 11 | *
 12 | * Unless required by applicable law or agreed to in writing, 
 13 | * software distributed under the License is distributed on an "AS IS" BASIS, 
 14 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
 15 | * See the License for the specific language governing permissions and 
 16 | * limitations under the License.
 17 | */
 18 | 
 19 | #include "coctx.h"
 20 | #include <string.h>
 21 | 
 22 | 
 23 | #define ESP 0
 24 | #define EIP 1
 25 | #define EAX 2
 26 | #define ECX 3
 27 | // -----------
 28 | #define RSP 0
 29 | #define RIP 1
 30 | #define RBX 2
 31 | #define RDI 3
 32 | #define RSI 4
 33 | 
 34 | #define RBP 5
 35 | #define R12 6
 36 | #define R13 7
 37 | #define R14 8
 38 | #define R15 9
 39 | #define RDX 10
 40 | #define RCX 11
 41 | #define R8 12
 42 | #define R9 13
 43 | 
 44 | 
 45 | //----- --------
 46 | // 32 bit
 47 | // | regs[0]: ret |
 48 | // | regs[1]: ebx |
 49 | // | regs[2]: ecx |
 50 | // | regs[3]: edx |
 51 | // | regs[4]: edi |
 52 | // | regs[5]: esi |
 53 | // | regs[6]: ebp |
 54 | // | regs[7]: eax |  = esp
 55 | enum
 56 | {
 57 | 	kEIP = 0,
 58 | 	kESP = 7,
 59 | };
 60 | 
 61 | //-------------
 62 | // 64 bit
 63 | //low | regs[0]: r15 |
 64 | //    | regs[1]: r14 |
 65 | //    | regs[2]: r13 |
 66 | //    | regs[3]: r12 |
 67 | //    | regs[4]: r9  |
 68 | //    | regs[5]: r8  | 
 69 | //    | regs[6]: rbp |
 70 | //    | regs[7]: rdi |
 71 | //    | regs[8]: rsi |
 72 | //    | regs[9]: ret |  //ret func addr
 73 | //    | regs[10]: rdx |
 74 | //    | regs[11]: rcx | 
 75 | //    | regs[12]: rbx |
 76 | //hig | regs[13]: rsp |
 77 | enum
 78 | {
 79 | 	kRDI = 7,
 80 | 	kRSI = 8,
 81 | 	kRETAddr = 9,
 82 | 	kRSP = 13,
 83 | };
 84 | 
 85 | //64 bit
 86 | extern "C"
 87 | {
 88 | 	extern void coctx_swap( coctx_t *,coctx_t* ) asm("coctx_swap");
 89 | };
 90 | #if defined(__i386__)
 91 | int coctx_init( coctx_t *ctx )
 92 | {
 93 | 	memset( ctx,0,sizeof(*ctx));
 94 | 	return 0;
 95 | }
 96 | int coctx_make( coctx_t *ctx,coctx_pfn_t pfn,const void *s,const void *s1 )
 97 | {
 98 | 	//make room for coctx_param
 99 | 	char *sp = ctx->ss_sp + ctx->ss_size - sizeof(coctx_param_t);
100 | 	sp = (char*)((unsigned long)sp & -16L);
101 | 
102 | 	
103 | 	coctx_param_t* param = (coctx_param_t*)sp ;
104 | 	param->s1 = s;
105 | 	param->s2 = s1;
106 | 
107 | 	memset(ctx->regs, 0, sizeof(ctx->regs));
108 | 
109 | 	ctx->regs[ kESP ] = (char*)(sp) - sizeof(void*);
110 | 	ctx->regs[ kEIP ] = (char*)pfn;
111 | 
112 | 	return 0;
113 | }
114 | #elif defined(__x86_64__)
115 | int coctx_make( coctx_t *ctx,coctx_pfn_t pfn,const void *s,const void *s1 )
116 | {
117 | 	char *sp = ctx->ss_sp + ctx->ss_size;
118 | 	sp = (char*) ((unsigned long)sp & -16LL  );
119 | 
120 | 	memset(ctx->regs, 0, sizeof(ctx->regs));
121 | 
122 | 	ctx->regs[ kRSP ] = sp - 8;
123 | 
124 | 	ctx->regs[ kRETAddr] = (char*)pfn;
125 | 
126 | 	ctx->regs[ kRDI ] = (char*)s;
127 | 	ctx->regs[ kRSI ] = (char*)s1;
128 | 	return 0;
129 | }
130 | 
131 | int coctx_init( coctx_t *ctx )
132 | {
133 | 	memset( ctx,0,sizeof(*ctx));
134 | 	return 0;
135 | }
136 | 
137 | #endif
138 | 
139 | 


--------------------------------------------------------------------------------
/coctx.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | * Tencent is pleased to support the open source community by making Libco available.
 3 | 
 4 | * Copyright (C) 2014 THL A29 Limited, a Tencent company. All rights reserved.
 5 | *
 6 | * Licensed under the Apache License, Version 2.0 (the "License"); 
 7 | * you may not use this file except in compliance with the License. 
 8 | * You may obtain a copy of the License at
 9 | *
10 | *	http://www.apache.org/licenses/LICENSE-2.0
11 | *
12 | * Unless required by applicable law or agreed to in writing, 
13 | * software distributed under the License is distributed on an "AS IS" BASIS, 
14 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
15 | * See the License for the specific language governing permissions and 
16 | * limitations under the License.
17 | */
18 | 
19 | #ifndef __CO_CTX_H__
20 | #define __CO_CTX_H__
21 | #include <stdlib.h>
22 | typedef void* (*coctx_pfn_t)( void* s, void* s2 );
23 | struct coctx_param_t
24 | {
25 | 	const void *s1;
26 | 	const void *s2;
27 | };
28 | struct coctx_t
29 | {
30 | #if defined(__i386__)
31 | 	void *regs[ 8 ];
32 | #else
33 | 	void *regs[ 14 ];
34 | #endif
35 | 	size_t ss_size;
36 | 	char *ss_sp;
37 | 	
38 | };
39 | 
40 | int coctx_init( coctx_t *ctx );
41 | int coctx_make( coctx_t *ctx,coctx_pfn_t pfn,const void *s,const void *s1 );
42 | #endif
43 | 


--------------------------------------------------------------------------------
/coctx_swap.S:
--------------------------------------------------------------------------------
 1 | /*
 2 | * Tencent is pleased to support the open source community by making Libco available.
 3 | 
 4 | * Copyright (C) 2014 THL A29 Limited, a Tencent company. All rights reserved.
 5 | *
 6 | * Licensed under the Apache License, Version 2.0 (the "License"); 
 7 | * you may not use this file except in compliance with the License. 
 8 | * You may obtain a copy of the License at
 9 | *
10 | *	http://www.apache.org/licenses/LICENSE-2.0
11 | *
12 | * Unless required by applicable law or agreed to in writing, 
13 | * software distributed under the License is distributed on an "AS IS" BASIS, 
14 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
15 | * See the License for the specific language governing permissions and 
16 | * limitations under the License.
17 | */
18 | 
19 | .globl coctx_swap
20 | #if !defined( __APPLE__ )
21 | .type  coctx_swap, @function
22 | #endif
23 | coctx_swap:
24 | 
25 | #if defined(__i386__)
26 | 	leal 4(%esp), %eax //sp 
27 | 	movl 4(%esp), %esp 
28 | 	leal 32(%esp), %esp //parm a : &regs[7] + sizeof(void*)
29 | 
30 | 	pushl %eax //esp ->parm a 
31 | 
32 | 	pushl %ebp
33 | 	pushl %esi
34 | 	pushl %edi
35 | 	pushl %edx
36 | 	pushl %ecx
37 | 	pushl %ebx
38 | 	pushl -4(%eax)
39 | 
40 | 	
41 | 	movl 4(%eax), %esp //parm b -> &regs[0]
42 | 
43 | 	popl %eax  //ret func addr
44 | 	popl %ebx  
45 | 	popl %ecx
46 | 	popl %edx
47 | 	popl %edi
48 | 	popl %esi
49 | 	popl %ebp
50 | 	popl %esp
51 | 	pushl %eax //set ret func addr
52 | 
53 | 	xorl %eax, %eax
54 | 	ret
55 | 
56 | #elif defined(__x86_64__)
57 | 	leaq 8(%rsp),%rax
58 | 	leaq 112(%rdi),%rsp
59 | 	pushq %rax
60 | 	pushq %rbx
61 | 	pushq %rcx
62 | 	pushq %rdx
63 | 
64 | 	pushq -8(%rax) //ret func addr
65 | 
66 | 	pushq %rsi
67 | 	pushq %rdi
68 | 	pushq %rbp
69 | 	pushq %r8
70 | 	pushq %r9
71 | 	pushq %r12
72 | 	pushq %r13
73 | 	pushq %r14
74 | 	pushq %r15
75 | 	
76 | 	movq %rsi, %rsp
77 | 	popq %r15
78 | 	popq %r14
79 | 	popq %r13
80 | 	popq %r12
81 | 	popq %r9
82 | 	popq %r8
83 | 	popq %rbp
84 | 	popq %rdi
85 | 	popq %rsi
86 | 	popq %rax //ret func addr
87 | 	popq %rdx
88 | 	popq %rcx
89 | 	popq %rbx
90 | 	popq %rsp
91 | 	pushq %rax
92 | 	
93 | 	xorl %eax, %eax
94 | 	ret
95 | #endif
96 | 


--------------------------------------------------------------------------------
/example_closure.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | * Tencent is pleased to support the open source community by making Libco available.
 3 | 
 4 | * Copyright (C) 2014 THL A29 Limited, a Tencent company. All rights reserved.
 5 | *
 6 | * Licensed under the Apache License, Version 2.0 (the "License"); 
 7 | * you may not use this file except in compliance with the License. 
 8 | * You may obtain a copy of the License at
 9 | *
10 | *	http://www.apache.org/licenses/LICENSE-2.0
11 | *
12 | * Unless required by applicable law or agreed to in writing, 
13 | * software distributed under the License is distributed on an "AS IS" BASIS, 
14 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
15 | * See the License for the specific language governing permissions and 
16 | * limitations under the License.
17 | */
18 | 
19 | #include "co_closure.h"
20 | #include <stdio.h>
21 | #include <stdlib.h>
22 | #include <vector>
23 | #include <pthread.h>
24 | #include <unistd.h>
25 | using namespace std;
26 | 
27 | static void *thread_func( void * arg )
28 | {
29 | 	stCoClosure_t *p = (stCoClosure_t*) arg;
30 | 	p->exec();
31 | 	return 0;
32 | }
33 | static void batch_exec( vector<stCoClosure_t*> &v )
34 | {
35 | 	vector<pthread_t> ths;
36 | 	for( size_t i=0;i<v.size();i++ )
37 | 	{
38 | 		pthread_t tid;
39 | 		pthread_create( &tid,0,thread_func,v[i] );
40 | 		ths.push_back( tid );
41 | 	}
42 | 	for( size_t i=0;i<v.size();i++ )
43 | 	{
44 | 		pthread_join( ths[i],0 );
45 | 	}
46 | }
47 | int main( int argc,char *argv[] )
48 | {
49 | 	vector< stCoClosure_t* > v;
50 | 
51 | 	pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;
52 | 
53 | 	int total = 100;
54 | 	vector<int> v2;
55 | 	co_ref( ref,total,v2,m);
56 | 	for(int i=0;i<10;i++)
57 | 	{
58 | 		co_func( f,ref,i )
59 | 		{
60 | 			printf("ref.total %d i %d\n",ref.total,i );
61 | 			//lock
62 | 			pthread_mutex_lock(&ref.m);
63 | 			ref.v2.push_back( i );
64 | 			pthread_mutex_unlock(&ref.m);
65 | 			//unlock
66 | 		}
67 | 		co_func_end;
68 | 		v.push_back( new f( ref,i ) );
69 | 	}
70 | 	for(int i=0;i<2;i++)
71 | 	{
72 | 		co_func( f2,i )
73 | 		{
74 | 			printf("i: %d\n",i);
75 | 			for(int j=0;j<2;j++)
76 | 			{
77 | 				usleep( 1000 );
78 | 				printf("i %d j %d\n",i,j);
79 | 			}
80 | 		}
81 | 		co_func_end;
82 | 		v.push_back( new f2( i ) );
83 | 	}
84 | 
85 | 	batch_exec( v );
86 | 	printf("done\n");
87 | 
88 | 	return 0;
89 | }
90 | 
91 | 
92 | 


--------------------------------------------------------------------------------
/example_cond.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | * Tencent is pleased to support the open source community by making Libco available.
 3 | 
 4 | * Copyright (C) 2014 THL A29 Limited, a Tencent company. All rights reserved.
 5 | *
 6 | * Licensed under the Apache License, Version 2.0 (the "License"); 
 7 | * you may not use this file except in compliance with the License. 
 8 | * You may obtain a copy of the License at
 9 | *
10 | *	http://www.apache.org/licenses/LICENSE-2.0
11 | *
12 | * Unless required by applicable law or agreed to in writing, 
13 | * software distributed under the License is distributed on an "AS IS" BASIS, 
14 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
15 | * See the License for the specific language governing permissions and 
16 | * limitations under the License.
17 | */
18 | 
19 | #include <unistd.h>
20 | #include <stdio.h>
21 | #include <stdlib.h>
22 | #include <queue>
23 | #include "co_routine.h"
24 | using namespace std;
25 | struct stTask_t
26 | {
27 | 	int id;
28 | };
29 | struct stEnv_t
30 | {
31 | 	stCoCond_t* cond;
32 | 	queue<stTask_t*> task_queue;
33 | };
34 | void* Producer(void* args)
35 | {
36 | 	co_enable_hook_sys();
37 | 	stEnv_t* env=  (stEnv_t*)args;
38 | 	int id = 0;
39 | 	while (true)
40 | 	{
41 | 		stTask_t* task = (stTask_t*)calloc(1, sizeof(stTask_t));
42 | 		task->id = id++;
43 | 		env->task_queue.push(task);
44 | 		printf("%s:%d produce task %d\n", __func__, __LINE__, task->id);
45 | 		co_cond_signal(env->cond);
46 | 		poll(NULL, 0, 1000);
47 | 	}
48 | 	return NULL;
49 | }
50 | void* Consumer(void* args)
51 | {
52 | 	co_enable_hook_sys();
53 | 	stEnv_t* env = (stEnv_t*)args;
54 | 	while (true)
55 | 	{
56 | 		if (env->task_queue.empty())
57 | 		{
58 | 			co_cond_timedwait(env->cond, -1);
59 | 			continue;
60 | 		}
61 | 		stTask_t* task = env->task_queue.front();
62 | 		env->task_queue.pop();
63 | 		printf("%s:%d consume task %d\n", __func__, __LINE__, task->id);
64 | 		free(task);
65 | 	}
66 | 	return NULL;
67 | }
68 | int main()
69 | {
70 | 	stEnv_t* env = new stEnv_t;
71 | 	env->cond = co_cond_alloc();
72 | 
73 | 	stCoRoutine_t* consumer_routine;
74 | 	co_create(&consumer_routine, NULL, Consumer, env);
75 | 	co_resume(consumer_routine);
76 | 
77 | 	stCoRoutine_t* producer_routine;
78 | 	co_create(&producer_routine, NULL, Producer, env);
79 | 	co_resume(producer_routine);
80 | 	
81 | 	co_eventloop(co_get_epoll_ct(), NULL, NULL);
82 | 	return 0;
83 | }
84 | 


--------------------------------------------------------------------------------
/example_copystack.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | * Tencent is pleased to support the open source community by making Libco available.
 3 | 
 4 | * Copyright (C) 2014 THL A29 Limited, a Tencent company. All rights reserved.
 5 | *
 6 | * Licensed under the Apache License, Version 2.0 (the "License"); 
 7 | * you may not use this file except in compliance with the License. 
 8 | * You may obtain a copy of the License at
 9 | *
10 | *	http://www.apache.org/licenses/LICENSE-2.0
11 | *
12 | * Unless required by applicable law or agreed to in writing, 
13 | * software distributed under the License is distributed on an "AS IS" BASIS, 
14 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
15 | * See the License for the specific language governing permissions and 
16 | * limitations under the License.
17 | */
18 | 
19 | #include <stdio.h>
20 | #include <stdlib.h>
21 | #include <unistd.h>
22 | #include <sys/time.h>
23 | #include <sys/epoll.h>
24 | #include <errno.h>
25 | #include <string.h>
26 | #include "coctx.h"
27 | #include "co_routine.h"
28 | #include "co_routine_inner.h"
29 | 
30 | void* RoutineFunc(void* args)
31 | {
32 | 	co_enable_hook_sys();
33 | 	int* routineid = (int*)args;
34 | 	while (true)
35 | 	{
36 | 		char sBuff[128];
37 | 		sprintf(sBuff, "from routineid %d stack addr %p\n", *routineid, sBuff);
38 | 
39 | 		printf("%s", sBuff);
40 | 		poll(NULL, 0, 1000); //sleep 1s
41 | 	}
42 | 	return NULL;
43 | }
44 | 
45 | int main()
46 | {
47 | 	stShareStack_t* share_stack= co_alloc_sharestack(1, 1024 * 128);
48 | 	stCoRoutineAttr_t attr;
49 | 	attr.stack_size = 0;
50 | 	attr.share_stack = share_stack;
51 | 
52 | 	stCoRoutine_t* co[2];
53 | 	int routineid[2];
54 | 	for (int i = 0; i < 2; i++)
55 | 	{
56 | 		routineid[i] = i;
57 | 		co_create(&co[i], &attr, RoutineFunc, routineid + i);
58 | 		co_resume(co[i]);
59 | 	}
60 | 	co_eventloop(co_get_epoll_ct(), NULL, NULL);
61 | 	return 0;
62 | }
63 | 


--------------------------------------------------------------------------------
/example_echocli.cpp:
--------------------------------------------------------------------------------
  1 | /*
  2 | * Tencent is pleased to support the open source community by making Libco available.
  3 | 
  4 | * Copyright (C) 2014 THL A29 Limited, a Tencent company. All rights reserved.
  5 | *
  6 | * Licensed under the Apache License, Version 2.0 (the "License"); 
  7 | * you may not use this file except in compliance with the License. 
  8 | * You may obtain a copy of the License at
  9 | *
 10 | *	http://www.apache.org/licenses/LICENSE-2.0
 11 | *
 12 | * Unless required by applicable law or agreed to in writing, 
 13 | * software distributed under the License is distributed on an "AS IS" BASIS, 
 14 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
 15 | * See the License for the specific language governing permissions and 
 16 | * limitations under the License.
 17 | */
 18 | 
 19 | #include "co_routine.h"
 20 | 
 21 | #include <errno.h>
 22 | #include <string.h>
 23 | 
 24 | #include <stdio.h>
 25 | #include <stdlib.h>
 26 | #include <stdint.h>
 27 | #include <time.h>
 28 | #include <stack>
 29 | 
 30 | #include <sys/socket.h>
 31 | #include <netinet/in.h>
 32 | #include <sys/un.h>
 33 | #include <fcntl.h>
 34 | #include <arpa/inet.h>
 35 | #include <unistd.h>
 36 | #include <signal.h>
 37 | 
 38 | using namespace std;
 39 | struct stEndPoint
 40 | {
 41 | 	char *ip;
 42 | 	unsigned short int port;
 43 | };
 44 | 
 45 | static void SetAddr(const char *pszIP,const unsigned short shPort,struct sockaddr_in &addr)
 46 | {
 47 | 	bzero(&addr,sizeof(addr));
 48 | 	addr.sin_family = AF_INET;
 49 | 	addr.sin_port = htons(shPort);
 50 | 	int nIP = 0;
 51 | 	if( !pszIP || '\0' == *pszIP   
 52 | 			|| 0 == strcmp(pszIP,"0") || 0 == strcmp(pszIP,"0.0.0.0") 
 53 | 			|| 0 == strcmp(pszIP,"*") 
 54 | 	  )
 55 | 	{
 56 | 		nIP = htonl(INADDR_ANY);
 57 | 	}
 58 | 	else
 59 | 	{
 60 | 		nIP = inet_addr(pszIP);
 61 | 	}
 62 | 	addr.sin_addr.s_addr = nIP;
 63 | 
 64 | }
 65 | 
 66 | static int iSuccCnt = 0;
 67 | static int iFailCnt = 0;
 68 | static int iTime = 0;
 69 | 
 70 | void AddSuccCnt()
 71 | {
 72 | 	int now = time(NULL);
 73 | 	if (now >iTime)
 74 | 	{
 75 | 		printf("time %d Succ Cnt %d Fail Cnt %d\n", iTime, iSuccCnt, iFailCnt);
 76 | 		iTime = now;
 77 | 		iSuccCnt = 0;
 78 | 		iFailCnt = 0;
 79 | 	}
 80 | 	else
 81 | 	{
 82 | 		iSuccCnt++;
 83 | 	}
 84 | }
 85 | void AddFailCnt()
 86 | {
 87 | 	int now = time(NULL);
 88 | 	if (now >iTime)
 89 | 	{
 90 | 		printf("time %d Succ Cnt %d Fail Cnt %d\n", iTime, iSuccCnt, iFailCnt);
 91 | 		iTime = now;
 92 | 		iSuccCnt = 0;
 93 | 		iFailCnt = 0;
 94 | 	}
 95 | 	else
 96 | 	{
 97 | 		iFailCnt++;
 98 | 	}
 99 | }
100 | 
101 | static void *readwrite_routine( void *arg )
102 | {
103 | 
104 | 	co_enable_hook_sys();
105 | 
106 | 	stEndPoint *endpoint = (stEndPoint *)arg;
107 | 	char str[8]="sarlmol";
108 | 	char buf[ 1024 * 16 ];
109 | 	int fd = -1;
110 | 	int ret = 0;
111 | 	for(;;)
112 | 	{
113 | 		if ( fd < 0 )
114 | 		{
115 | 			fd = socket(PF_INET, SOCK_STREAM, 0);
116 | 			struct sockaddr_in addr;
117 | 			SetAddr(endpoint->ip, endpoint->port, addr);
118 | 			ret = connect(fd,(struct sockaddr*)&addr,sizeof(addr));
119 | 						
120 | 			if ( errno == EALREADY || errno == EINPROGRESS )
121 | 			{       
122 | 				struct pollfd pf = { 0 };
123 | 				pf.fd = fd;
124 | 				pf.events = (POLLOUT|POLLERR|POLLHUP);
125 | 				co_poll( co_get_epoll_ct(),&pf,1,200);
126 | 				//check connect
127 | 				int error = 0;
128 | 				uint32_t socklen = sizeof(error);
129 | 				errno = 0;
130 | 				ret = getsockopt(fd, SOL_SOCKET, SO_ERROR,(void *)&error,  &socklen);
131 | 				if ( ret == -1 ) 
132 | 				{       
133 | 					//printf("getsockopt ERROR ret %d %d:%s\n", ret, errno, strerror(errno));
134 | 					close(fd);
135 | 					fd = -1;
136 | 					AddFailCnt();
137 | 					continue;
138 | 				}       
139 | 				if ( error ) 
140 | 				{       
141 | 					errno = error;
142 | 					//printf("connect ERROR ret %d %d:%s\n", error, errno, strerror(errno));
143 | 					close(fd);
144 | 					fd = -1;
145 | 					AddFailCnt();
146 | 					continue;
147 | 				}       
148 | 			} 
149 | 	  			
150 | 		}
151 | 		
152 | 		ret = write( fd,str, 8);
153 | 		if ( ret > 0 )
154 | 		{
155 | 			ret = read( fd,buf, sizeof(buf) );
156 | 			if ( ret <= 0 )
157 | 			{
158 | 				//printf("co %p read ret %d errno %d (%s)\n",
159 | 				//		co_self(), ret,errno,strerror(errno));
160 | 				close(fd);
161 | 				fd = -1;
162 | 				AddFailCnt();
163 | 			}
164 | 			else
165 | 			{
166 | 				//printf("echo %s fd %d\n", buf,fd);
167 | 				AddSuccCnt();
168 | 			}
169 | 		}
170 | 		else
171 | 		{
172 | 			//printf("co %p write ret %d errno %d (%s)\n",
173 | 			//		co_self(), ret,errno,strerror(errno));
174 | 			close(fd);
175 | 			fd = -1;
176 | 			AddFailCnt();
177 | 		}
178 | 	}
179 | 	return 0;
180 | }
181 | 
182 | int main(int argc,char *argv[])
183 | {
184 | 	stEndPoint endpoint;
185 | 	endpoint.ip = argv[1];
186 | 	endpoint.port = atoi(argv[2]);
187 | 	int cnt = atoi( argv[3] );
188 | 	int proccnt = atoi( argv[4] );
189 | 	
190 | 	struct sigaction sa;
191 | 	sa.sa_handler = SIG_IGN;
192 | 	sigaction( SIGPIPE, &sa, NULL );
193 | 	
194 | 	for(int k=0;k<proccnt;k++)
195 | 	{
196 | 
197 | 		pid_t pid = fork();
198 | 		if( pid > 0 )
199 | 		{
200 | 			continue;
201 | 		}
202 | 		else if( pid < 0 )
203 | 		{
204 | 			break;
205 | 		}
206 | 		for(int i=0;i<cnt;i++)
207 | 		{
208 | 			stCoRoutine_t *co = 0;
209 | 			co_create( &co,NULL,readwrite_routine, &endpoint);
210 | 			co_resume( co );
211 | 		}
212 | 		co_eventloop( co_get_epoll_ct(),0,0 );
213 | 
214 | 		exit(0);
215 | 	}
216 | 	return 0;
217 | }
218 | /*./example_echosvr 127.0.0.1 10000 100 50*/
219 | 


--------------------------------------------------------------------------------
/example_echosvr.cpp:
--------------------------------------------------------------------------------
  1 | /*
  2 | * Tencent is pleased to support the open source community by making Libco available.
  3 | 
  4 | * Copyright (C) 2014 THL A29 Limited, a Tencent company. All rights reserved.
  5 | *
  6 | * Licensed under the Apache License, Version 2.0 (the "License"); 
  7 | * you may not use this file except in compliance with the License. 
  8 | * You may obtain a copy of the License at
  9 | *
 10 | *	http://www.apache.org/licenses/LICENSE-2.0
 11 | *
 12 | * Unless required by applicable law or agreed to in writing, 
 13 | * software distributed under the License is distributed on an "AS IS" BASIS, 
 14 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
 15 | * See the License for the specific language governing permissions and 
 16 | * limitations under the License.
 17 | */
 18 | 
 19 | 
 20 | 
 21 | #include "co_routine.h"
 22 | 
 23 | #include <stdio.h>
 24 | #include <stdlib.h>
 25 | #include <stdint.h>
 26 | #include <sys/time.h>
 27 | #include <stack>
 28 | 
 29 | #include <sys/socket.h>
 30 | #include <netinet/in.h>
 31 | #include <sys/un.h>
 32 | #include <fcntl.h>
 33 | #include <arpa/inet.h>
 34 | #include <unistd.h>
 35 | 
 36 | using namespace std;
 37 | struct task_t
 38 | {
 39 | 	stCoRoutine_t *co;
 40 | 	int fd;
 41 | };
 42 | 
 43 | static stack<task_t*> g_readwrite;
 44 | static int g_listen_fd = -1;
 45 | static int SetNonBlock(int iSock)
 46 | {
 47 |     int iFlags;
 48 | 
 49 |     iFlags = fcntl(iSock, F_GETFL, 0);
 50 |     iFlags |= O_NONBLOCK;
 51 |     iFlags |= O_NDELAY;
 52 |     int ret = fcntl(iSock, F_SETFL, iFlags);
 53 |     return ret;
 54 | }
 55 | 
 56 | static void *readwrite_routine( void *arg )
 57 | {
 58 | 
 59 | 	co_enable_hook_sys();
 60 | 
 61 | 	task_t *co = (task_t*)arg;
 62 | 	char buf[ 1024 * 16 ];
 63 | 	for(;;)
 64 | 	{
 65 | 		if( -1 == co->fd )
 66 | 		{
 67 | 			g_readwrite.push( co );
 68 | 			co_yield_ct();
 69 | 			continue;
 70 | 		}
 71 | 
 72 | 		int fd = co->fd;
 73 | 		co->fd = -1;
 74 | 
 75 | 		for(;;)
 76 | 		{
 77 | 			struct pollfd pf = { 0 };
 78 | 			pf.fd = fd;
 79 | 			pf.events = (POLLIN|POLLERR|POLLHUP);
 80 | 			co_poll( co_get_epoll_ct(),&pf,1,1000);
 81 | 
 82 | 			int ret = read( fd,buf,sizeof(buf) );
 83 | 			if( ret > 0 )
 84 | 			{
 85 | 				ret = write( fd,buf,ret );
 86 | 			}
 87 | 			if( ret <= 0 )
 88 | 			{
 89 | 				close( fd );
 90 | 				break;
 91 | 			}
 92 | 		}
 93 | 
 94 | 	}
 95 | 	return 0;
 96 | }
 97 | int co_accept(int fd, struct sockaddr *addr, socklen_t *len );
 98 | static void *accept_routine( void * )
 99 | {
100 | 	co_enable_hook_sys();
101 | 	printf("accept_routine\n");
102 | 	fflush(stdout);
103 | 	for(;;)
104 | 	{
105 | 		//printf("pid %ld g_readwrite.size %ld\n",getpid(),g_readwrite.size());
106 | 		if( g_readwrite.empty() )
107 | 		{
108 | 			printf("empty\n"); //sleep
109 | 			struct pollfd pf = { 0 };
110 | 			pf.fd = -1;
111 | 			poll( &pf,1,1000);
112 | 
113 | 			continue;
114 | 
115 | 		}
116 | 		struct sockaddr_in addr; //maybe sockaddr_un;
117 | 		memset( &addr,0,sizeof(addr) );
118 | 		socklen_t len = sizeof(addr);
119 | 
120 | 		int fd = co_accept(g_listen_fd, (struct sockaddr *)&addr, &len);
121 | 		if( fd < 0 )
122 | 		{
123 | 			struct pollfd pf = { 0 };
124 | 			pf.fd = g_listen_fd;
125 | 			pf.events = (POLLIN|POLLERR|POLLHUP);
126 | 			co_poll( co_get_epoll_ct(),&pf,1,1000 );
127 | 			continue;
128 | 		}
129 | 		if( g_readwrite.empty() )
130 | 		{
131 | 			close( fd );
132 | 			continue;
133 | 		}
134 | 		SetNonBlock( fd );
135 | 		task_t *co = g_readwrite.top();
136 | 		co->fd = fd;
137 | 		g_readwrite.pop();
138 | 		co_resume( co->co );
139 | 	}
140 | 	return 0;
141 | }
142 | 
143 | static void SetAddr(const char *pszIP,const unsigned short shPort,struct sockaddr_in &addr)
144 | {
145 | 	bzero(&addr,sizeof(addr));
146 | 	addr.sin_family = AF_INET;
147 | 	addr.sin_port = htons(shPort);
148 | 	int nIP = 0;
149 | 	if( !pszIP || '\0' == *pszIP   
150 | 	    || 0 == strcmp(pszIP,"0") || 0 == strcmp(pszIP,"0.0.0.0") 
151 | 		|| 0 == strcmp(pszIP,"*") 
152 | 	  )
153 | 	{
154 | 		nIP = htonl(INADDR_ANY);
155 | 	}
156 | 	else
157 | 	{
158 | 		nIP = inet_addr(pszIP);
159 | 	}
160 | 	addr.sin_addr.s_addr = nIP;
161 | 
162 | }
163 | 
164 | static int CreateTcpSocket(const unsigned short shPort /* = 0 */,const char *pszIP /* = "*" */,bool bReuse /* = false */)
165 | {
166 | 	int fd = socket(AF_INET,SOCK_STREAM, IPPROTO_TCP);
167 | 	if( fd >= 0 )
168 | 	{
169 | 		if(shPort != 0)
170 | 		{
171 | 			if(bReuse)
172 | 			{
173 | 				int nReuseAddr = 1;
174 | 				setsockopt(fd,SOL_SOCKET,SO_REUSEADDR,&nReuseAddr,sizeof(nReuseAddr));
175 | 			}
176 | 			struct sockaddr_in addr ;
177 | 			SetAddr(pszIP,shPort,addr);
178 | 			int ret = bind(fd,(struct sockaddr*)&addr,sizeof(addr));
179 | 			if( ret != 0)
180 | 			{
181 | 				close(fd);
182 | 				return -1;
183 | 			}
184 | 		}
185 | 	}
186 | 	return fd;
187 | }
188 | 
189 | 
190 | int main(int argc,char *argv[])
191 | {
192 | 	const char *ip = argv[1];
193 | 	int port = atoi( argv[2] );
194 | 	int cnt = atoi( argv[3] );
195 | 	int proccnt = atoi( argv[4] );
196 | 
197 | 	g_listen_fd = CreateTcpSocket( port,ip,true );
198 | 	listen( g_listen_fd,1024 );
199 | 	printf("listen %d %s:%d\n",g_listen_fd,ip,port);
200 | 
201 | 	SetNonBlock( g_listen_fd );
202 | 
203 | 	for(int k=0;k<proccnt;k++)
204 | 	{
205 | 
206 | 		pid_t pid = fork();
207 | 		if( pid > 0 )
208 | 		{
209 | 			continue;
210 | 		}
211 | 		else if( pid < 0 )
212 | 		{
213 | 			break;
214 | 		}
215 | 		for(int i=0;i<cnt;i++)
216 | 		{
217 | 			task_t * task = (task_t*)calloc( 1,sizeof(task_t) );
218 | 			task->fd = -1;
219 | 
220 | 			co_create( &(task->co),NULL,readwrite_routine,task );
221 | 			co_resume( task->co );
222 | 
223 | 		}
224 | 		stCoRoutine_t *accept_co = NULL;
225 | 		co_create( &accept_co,NULL,accept_routine,0 );
226 | 		co_resume( accept_co );
227 | 
228 | 		co_eventloop( co_get_epoll_ct(),0,0 );
229 | 
230 | 		exit(0);
231 | 	}
232 | 	return 0;
233 | }
234 | 
235 | 


--------------------------------------------------------------------------------
/example_poll.cpp:
--------------------------------------------------------------------------------
  1 | /*
  2 | * Tencent is pleased to support the open source community by making Libco available.
  3 | 
  4 | * Copyright (C) 2014 THL A29 Limited, a Tencent company. All rights reserved.
  5 | *
  6 | * Licensed under the Apache License, Version 2.0 (the "License"); 
  7 | * you may not use this file except in compliance with the License. 
  8 | * You may obtain a copy of the License at
  9 | *
 10 | *	http://www.apache.org/licenses/LICENSE-2.0
 11 | *
 12 | * Unless required by applicable law or agreed to in writing, 
 13 | * software distributed under the License is distributed on an "AS IS" BASIS, 
 14 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
 15 | * See the License for the specific language governing permissions and 
 16 | * limitations under the License.
 17 | */
 18 | 
 19 | #include "co_routine.h"
 20 | 
 21 | #include <stdio.h>
 22 | #include <stdlib.h>
 23 | #include <stdint.h>
 24 | #include <sys/time.h>
 25 | #include <stack>
 26 | 
 27 | #include <sys/socket.h>
 28 | #include <netinet/in.h>
 29 | #include <sys/un.h>
 30 | #include <fcntl.h>
 31 | #include <arpa/inet.h>
 32 | #include <errno.h>
 33 | #include <vector>
 34 | #include <set>
 35 | #include <unistd.h>
 36 | using namespace std;
 37 | 
 38 | struct task_t
 39 | {
 40 | 	stCoRoutine_t *co;
 41 | 	int fd;
 42 | 	struct sockaddr_in addr;
 43 | };
 44 | 
 45 | static int SetNonBlock(int iSock)
 46 | {
 47 |     int iFlags;
 48 | 
 49 |     iFlags = fcntl(iSock, F_GETFL, 0);
 50 |     iFlags |= O_NONBLOCK;
 51 |     iFlags |= O_NDELAY;
 52 |     int ret = fcntl(iSock, F_SETFL, iFlags);
 53 |     return ret;
 54 | }
 55 | 
 56 | 
 57 | 
 58 | static void SetAddr(const char *pszIP,const unsigned short shPort,struct sockaddr_in &addr)
 59 | {
 60 | 	bzero(&addr,sizeof(addr));
 61 | 	addr.sin_family = AF_INET;
 62 | 	addr.sin_port = htons(shPort);
 63 | 	int nIP = 0;
 64 | 	if( !pszIP || '\0' == *pszIP   
 65 | 	    || 0 == strcmp(pszIP,"0") || 0 == strcmp(pszIP,"0.0.0.0") 
 66 | 		|| 0 == strcmp(pszIP,"*") 
 67 | 	  )
 68 | 	{
 69 | 		nIP = htonl(INADDR_ANY);
 70 | 	}
 71 | 	else
 72 | 	{
 73 | 		nIP = inet_addr(pszIP);
 74 | 	}
 75 | 	addr.sin_addr.s_addr = nIP;
 76 | 
 77 | }
 78 | 
 79 | static int CreateTcpSocket(const unsigned short shPort  = 0 ,const char *pszIP  = "*" ,bool bReuse  = false )
 80 | {
 81 | 	int fd = socket(AF_INET,SOCK_STREAM, IPPROTO_TCP);
 82 | 	if( fd >= 0 )
 83 | 	{
 84 | 		if(shPort != 0)
 85 | 		{
 86 | 			if(bReuse)
 87 | 			{
 88 | 				int nReuseAddr = 1;
 89 | 				setsockopt(fd,SOL_SOCKET,SO_REUSEADDR,&nReuseAddr,sizeof(nReuseAddr));
 90 | 			}
 91 | 			struct sockaddr_in addr ;
 92 | 			SetAddr(pszIP,shPort,addr);
 93 | 			int ret = bind(fd,(struct sockaddr*)&addr,sizeof(addr));
 94 | 			if( ret != 0)
 95 | 			{
 96 | 				close(fd);
 97 | 				return -1;
 98 | 			}
 99 | 		}
100 | 	}
101 | 	return fd;
102 | }
103 | 
104 | static void *poll_routine( void *arg )
105 | {
106 | 	co_enable_hook_sys();
107 | 
108 | 	vector<task_t> &v = *(vector<task_t>*)arg;
109 | 	for(size_t i=0;i<v.size();i++)
110 | 	{
111 | 		int fd = CreateTcpSocket();
112 | 		SetNonBlock( fd );
113 | 		v[i].fd = fd;
114 | 
115 | 		int ret = connect(fd,(struct sockaddr*)&v[i].addr,sizeof( v[i].addr )); 
116 | 		printf("co %p connect i %ld ret %d errno %d (%s)\n",
117 | 			co_self(),i,ret,errno,strerror(errno));
118 | 	}
119 | 	struct pollfd *pf = (struct pollfd*)calloc( 1,sizeof(struct pollfd) * v.size() );
120 | 
121 | 	for(size_t i=0;i<v.size();i++)
122 | 	{
123 | 		pf[i].fd = v[i].fd;
124 | 		pf[i].events = ( POLLOUT | POLLERR | POLLHUP );
125 | 	}
126 | 	set<int> setRaiseFds;
127 | 	size_t iWaitCnt = v.size();
128 | 	for(;;)
129 | 	{
130 | 		int ret = poll( pf,iWaitCnt,1000 );
131 | 		printf("co %p poll wait %ld ret %d\n",
132 | 				co_self(),iWaitCnt,ret);
133 | 		for(int i=0;i<ret;i++)
134 | 		{
135 | 			printf("co %p fire fd %d revents 0x%X POLLOUT 0x%X POLLERR 0x%X POLLHUP 0x%X\n",
136 | 					co_self(),
137 | 					pf[i].fd,
138 | 					pf[i].revents,
139 | 					POLLOUT,
140 | 					POLLERR,
141 | 					POLLHUP
142 | 					);
143 | 			setRaiseFds.insert( pf[i].fd );
144 | 		}
145 | 		if( setRaiseFds.size() == v.size())
146 | 		{
147 | 			break;
148 | 		}
149 | 		if( ret <= 0 )
150 | 		{
151 | 			break;
152 | 		}
153 | 
154 | 		iWaitCnt = 0;
155 | 		for(size_t i=0;i<v.size();i++)
156 | 		{
157 | 			if( setRaiseFds.find( v[i].fd ) == setRaiseFds.end() )
158 | 			{
159 | 				pf[ iWaitCnt ].fd = v[i].fd;
160 | 				pf[ iWaitCnt ].events = ( POLLOUT | POLLERR | POLLHUP );
161 | 				++iWaitCnt;
162 | 			}
163 | 		}
164 | 	}
165 | 	for(size_t i=0;i<v.size();i++)
166 | 	{
167 | 		close( v[i].fd );
168 | 		v[i].fd = -1;
169 | 	}
170 | 
171 | 	printf("co %p task cnt %ld fire %ld\n",
172 | 			co_self(),v.size(),setRaiseFds.size() );
173 | 	return 0;
174 | }
175 | int main(int argc,char *argv[])
176 | {
177 | 	vector<task_t> v;
178 | 	for(int i=1;i<argc;i+=2)
179 | 	{
180 | 		task_t task = { 0 };
181 | 		SetAddr( argv[i],atoi(argv[i+1]),task.addr );
182 | 		v.push_back( task );
183 | 	}
184 | 
185 | //------------------------------------------------------------------------------------
186 | 	printf("--------------------- main -------------------\n");
187 | 	vector<task_t> v2 = v;
188 | 	poll_routine( &v2 );
189 | 	printf("--------------------- routine -------------------\n");
190 | 
191 | 	for(int i=0;i<10;i++)
192 | 	{
193 | 		stCoRoutine_t *co = 0;
194 | 		vector<task_t> *v2 = new vector<task_t>();
195 | 		*v2 = v;
196 | 		co_create( &co,NULL,poll_routine,v2 );
197 | 		printf("routine i %d\n",i);
198 | 		co_resume( co );
199 | 	}
200 | 
201 | 	co_eventloop( co_get_epoll_ct(),0,0 );
202 | 
203 | 	return 0;
204 | }
205 | //./example_poll 127.0.0.1 12365 127.0.0.1 12222 192.168.1.1 1000 192.168.1.2 1111
206 | 
207 | 


--------------------------------------------------------------------------------
/example_setenv.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | * Tencent is pleased to support the open source community by making Libco available.
 3 | 
 4 | * Copyright (C) 2014 THL A29 Limited, a Tencent company. All rights reserved.
 5 | *
 6 | * Licensed under the Apache License, Version 2.0 (the "License"); 
 7 | * you may not use this file except in compliance with the License. 
 8 | * You may obtain a copy of the License at
 9 | *
10 | *	http://www.apache.org/licenses/LICENSE-2.0
11 | *
12 | * Unless required by applicable law or agreed to in writing, 
13 | * software distributed under the License is distributed on an "AS IS" BASIS, 
14 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
15 | * See the License for the specific language governing permissions and 
16 | * limitations under the License.
17 | */
18 | 
19 | #include <unistd.h>
20 | #include <stdio.h>
21 | #include <errno.h>
22 | #include <string.h>
23 | #include <stdlib.h>
24 | #include <queue>
25 | #include "co_routine.h"
26 | 
27 | const char* CGI_ENV_HOOK_LIST [] = 
28 | {
29 | 	"CGINAME",
30 | };
31 | struct stRoutineArgs_t
32 | {
33 | 	int iRoutineID;
34 | };
35 | void SetAndGetEnv(int iRoutineID)
36 | {
37 | 	printf("routineid %d begin\n", iRoutineID);
38 | 
39 | 	//use poll as sleep
40 | 	poll(NULL, 0, 500);
41 | 
42 | 	char sBuf[128];
43 | 	sprintf(sBuf, "cgi_routine_%d", iRoutineID);
44 | 	int ret = setenv("CGINAME", sBuf, 1);
45 | 	if (ret)
46 | 	{
47 | 		printf("%s:%d set env err ret %d errno %d %s\n", __func__, __LINE__,
48 | 				ret, errno, strerror(errno));
49 | 		return;
50 | 	}
51 | 	printf("routineid %d set env CGINAME %s\n", iRoutineID, sBuf);
52 | 
53 | 	poll(NULL, 0, 500);
54 | 
55 | 	char* env = getenv("CGINAME");
56 | 	if (!env)
57 | 	{
58 | 		printf("%s:%d get env err errno %d %s\n", __func__, __LINE__,
59 | 				errno, strerror(errno));
60 | 		return;
61 | 	}
62 | 	printf("routineid %d get env CGINAME %s\n", iRoutineID, env);
63 | }
64 | 
65 | void* RoutineFunc(void* args)
66 | {
67 | 	co_enable_hook_sys();
68 | 
69 | 	stRoutineArgs_t* g = (stRoutineArgs_t*)args;
70 | 
71 | 	SetAndGetEnv(g->iRoutineID);
72 | 	return NULL;
73 | }
74 | 
75 | int main(int argc, char* argv[])
76 | {
77 | 	co_set_env_list(CGI_ENV_HOOK_LIST, sizeof(CGI_ENV_HOOK_LIST) / sizeof(char*));
78 | 	stRoutineArgs_t  args[3];
79 | 	for (int i = 0; i < 3; i++)
80 | 	{
81 | 		stCoRoutine_t* co = NULL;
82 | 		args[i].iRoutineID = i;
83 | 		co_create(&co, NULL, RoutineFunc, &args[i]);
84 | 		co_resume(co);
85 | 	}
86 | 	co_eventloop(co_get_epoll_ct(), NULL, NULL);
87 | 	return 0;
88 | }
89 | 
90 | 


--------------------------------------------------------------------------------
/example_specific.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | * Tencent is pleased to support the open source community by making Libco available.
 3 | 
 4 | * Copyright (C) 2014 THL A29 Limited, a Tencent company. All rights reserved.
 5 | *
 6 | * Licensed under the Apache License, Version 2.0 (the "License"); 
 7 | * you may not use this file except in compliance with the License. 
 8 | * You may obtain a copy of the License at
 9 | *
10 | *	http://www.apache.org/licenses/LICENSE-2.0
11 | *
12 | * Unless required by applicable law or agreed to in writing, 
13 | * software distributed under the License is distributed on an "AS IS" BASIS, 
14 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
15 | * See the License for the specific language governing permissions and 
16 | * limitations under the License.
17 | */
18 | 
19 | #include "co_routine_specific.h"
20 | #include "co_routine.h"
21 | #include <unistd.h>
22 | #include <stdio.h>
23 | #include <vector>
24 | #include <iostream>
25 | using namespace std;
26 | struct stRoutineArgs_t
27 | {
28 | 	stCoRoutine_t* co;
29 | 	int routine_id;
30 | };
31 | struct stRoutineSpecificData_t
32 | {
33 | 	int idx;
34 | };
35 | 
36 | CO_ROUTINE_SPECIFIC(stRoutineSpecificData_t, __routine);
37 | 
38 | void* RoutineFunc(void* args)
39 | {
40 | 	co_enable_hook_sys();
41 | 	stRoutineArgs_t* routine_args = (stRoutineArgs_t*)args;
42 | 	__routine->idx = routine_args->routine_id;
43 | 	while (true)
44 | 	{
45 | 		printf("%s:%d routine specific data idx %d\n", __func__, __LINE__, __routine->idx);
46 | 		poll(NULL, 0, 1000);
47 | 	}
48 | 	return NULL;
49 | }
50 | int main()
51 | {
52 | 	stRoutineArgs_t args[10];
53 | 	for (int i = 0; i < 10; i++)
54 | 	{
55 | 		args[i].routine_id = i;
56 | 		co_create(&args[i].co, NULL, RoutineFunc, (void*)&args[i]);
57 | 		co_resume(args[i].co);
58 | 	}
59 | 	co_eventloop(co_get_epoll_ct(), NULL, NULL);
60 | 	return 0;
61 | }
62 | 


--------------------------------------------------------------------------------
/example_thread.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | * Tencent is pleased to support the open source community by making Libco available.
 3 | 
 4 | * Copyright (C) 2014 THL A29 Limited, a Tencent company. All rights reserved.
 5 | *
 6 | * Licensed under the Apache License, Version 2.0 (the "License"); 
 7 | * you may not use this file except in compliance with the License. 
 8 | * You may obtain a copy of the License at
 9 | *
10 | *	http://www.apache.org/licenses/LICENSE-2.0
11 | *
12 | * Unless required by applicable law or agreed to in writing, 
13 | * software distributed under the License is distributed on an "AS IS" BASIS, 
14 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
15 | * See the License for the specific language governing permissions and 
16 | * limitations under the License.
17 | */
18 | 
19 | 
20 | 
21 | #include "co_routine.h"
22 | #include "co_routine_inner.h"
23 | 
24 | #include <stdio.h>
25 | #include <stdlib.h>
26 | #include <stdint.h>
27 | #include <pthread.h>
28 | #include <unistd.h>
29 | 
30 | int loop(void *)
31 | {
32 | 	return 0;
33 | }
34 | static void *routine_func( void * )
35 | {
36 | 	stCoEpoll_t * ev = co_get_epoll_ct(); //ct = current thread
37 | 	co_eventloop( ev,loop,0 );
38 | 	return 0;
39 | }
40 | int main(int argc,char *argv[])
41 | {
42 | 	int cnt = atoi( argv[1] );
43 | 
44 | 	pthread_t tid[ cnt ];
45 | 	for(int i=0;i<cnt;i++)
46 | 	{
47 | 		pthread_create( tid + i,NULL,routine_func,0);
48 | 	}
49 | 	for(;;)
50 | 	{
51 | 		sleep(1);
52 | 	}
53 | 	
54 | 	return 0;
55 | }
56 | 
57 | 


--------------------------------------------------------------------------------