Changeset 731

Timestamp:

04/30/07 12:50:21 (2 years ago)

Author:

alo

Message:

Files:

cherokee/trunk/ChangeLog (modified) (1 diff)
cherokee/trunk/cherokee/fdpoll-epoll.c (modified) (3 diffs)
cherokee/trunk/cherokee/fdpoll-kqueue.c (modified) (4 diffs)
cherokee/trunk/cherokee/fdpoll-poll.c (modified) (3 diffs)
cherokee/trunk/cherokee/fdpoll-port.c (modified) (3 diffs)
cherokee/trunk/cherokee/fdpoll-select.c (modified) (3 diffs)
cherokee/trunk/cherokee/fdpoll-win32.c (modified) (3 diffs)
cherokee/trunk/cherokee/fdpoll.h (modified) (1 diff)
cherokee/trunk/cherokee/macros.h (modified) (2 diffs)
cherokee/trunk/cherokee/server.c (modified) (9 diffs)
cherokee/trunk/cherokee/thread.c (modified) (10 diffs)

Legend:

: Unmodified
: Added
: Removed
: Modified
: Copied
: Moved

cherokee/trunk/ChangeLog

r718	r731
	1	2007-04-30 A.D.F <adefacc@tin.it>
	2
	3	* cherokee/fdpoll.h:
	4	- added new macros FDPOLL_MODE_*.
	5
	6	* cherokee/macros.h:
	7	- added new macro MIN_THR_FDS and related tests.
	8
	9	* cherokee/server.c:
	10	- adjusted minimum number of fds (file descriptors)
	11	per thread;
	12	- substituted numeric constants 0 / 1 with
	13	equivalent defines FDPOLL_MODE_*.
	14
	15	* cherokee/thread.c, cherokee/fdpoll-*.c:
	16	- substituted numeric constants 0 / 1 with
	17	equivalent defines FDPOLL_MODE_*.
	18
1	19	2007-04-22 A.D.F <adefacc@tin.it>
2	20

cherokee/trunk/cherokee/fdpoll-epoll.c

r702	r731
96	96	ev.data.fd = fd;
97	97	switch (rw) {
98		case 0:
	98	case FDPOLL_MODE_READ:
99	99	ev.events = EPOLLIN \| EPOLLERR \| EPOLLHUP;
100	100	break;
101		case 1:
	101	case FDPOLL_MODE_WRITE:
102	102	ev.events = EPOLLOUT \| EPOLLERR \| EPOLLHUP;
103	103	break;
…	…
182	182
183	183	switch (rw) {
184		case 0:
	184	case FDPOLL_MODE_READ:
185	185	return events & (EPOLLIN \| EPOLLERR \| EPOLLHUP);
186		case 1:
	186	case FDPOLL_MODE_WRITE:
187	187	return events & (EPOLLOUT \| EPOLLERR \| EPOLLHUP);
188	188	default:
…	…
215	215
216	216	switch (rw) {
217		case 0:
	217	case FDPOLL_MODE_READ:
218	218	ev.events = EPOLLIN;
219	219	break;
220		case 1:
	220	case FDPOLL_MODE_WRITE:
221	221	ev.events = EPOLLOUT;
222	222	break;

cherokee/trunk/cherokee/fdpoll-kqueue.c

r703	r731
105	105	event->ident = fd;
106	106	switch (rw) {
107		case 0:
	107	case FDPOLL_MODE_READ:
108	108	event->filter = EVFILT_READ;
109	109	break;
110		case 1:
	110	case FDPOLL_MODE_WRITE:
111	111	event->filter = EVFILT_WRITE;
112	112	break;
…	…
117	117	event->fflags = 0;
118	118
119		fdp->fdinterest[fd]=rw;
	119	fdp->fdinterest[fd] = rw;
120	120	fdp->nchanges++;
121	121	return ret_ok;
…	…
201	201
202	202	switch (rw) {
203		case 0:
	203	case FDPOLL_MODE_READ:
204	204	events &= KQUEUE_READ_EVENT;
205	205	break;
206		case 1:
	206	case FDPOLL_MODE_WRITE:
207	207	events &= KQUEUE_WRITE_EVENT;
208	208	break;
…	…
229	229	* no longer interested on it.
230	230	*/
231		if ( rw && (fdp->fdinterest[fd] == 0) ) {
232		return _add_change(fdp, fd, 0, EV_DELETE);
233		} else if ( (rw==0 ) && (fdp->fdinterest[fd] == 1) ) {
234		return _add_change(fdp, fd, 1, EV_DELETE);
	231	if ( rw == FDPOLL_MODE_WRITE &&
	232	fdp->fdinterest[fd] == FDPOLL_MODE_READ ) {
	233	return _add_change(fdp, fd, FDPOLL_MODE_READ, EV_DELETE);
	234	}
	235	if ( rw == FDPOLL_MODE_READ && fdp->fdinterest[fd] == FDPOLL_MODE_WRITE ) {
	236	return _add_change(fdp, fd, FDPOLL_MODE_WRITE, EV_DELETE);
235	237	}
236	238

cherokee/trunk/cherokee/fdpoll-poll.c

r702	r731
83	83
84	84	switch (rw) {
85		case 0:
	85	case FDPOLL_MODE_READ:
86	86	fdp->pollfds[nfd->npollfds].events = POLLIN;
87	87	break;
88		case 1:
	88	case FDPOLL_MODE_WRITE:
89	89	fdp->pollfds[nfd->npollfds].events = POLLOUT;
90	90	break;
…	…
104	104	_set_mode (cherokee_fdpoll_poll_t *fdp, int fd, int rw)
105	105	{
106		fdp->pollfds[fdp->fdidx[fd]].events = (rw ? POLLOUT : POLLIN);
	106	fdp->pollfds[fdp->fdidx[fd]].events = (rw == FDPOLL_MODE_WRITE ? POLLOUT : POLLIN);
107	107	return ret_ok;
108	108	}
…	…
161	161
162	162	switch (rw) {
163		case 0:
	163	case FDPOLL_MODE_READ:
164	164	return revents & POLL_READ;
165		case 1:
	165	case FDPOLL_MODE_WRITE:
166	166	return revents & POLL_WRITE;
167	167	default:

cherokee/trunk/cherokee/fdpoll-port.c

r703	r731
118	118	int rc;
119	119
120		rc = fd_associate(fdp, fd, ~~rw?WRITE:READ~~);
	120	rc = fd_associate(fdp, fd, (rw == FDPOLL_MODE_WRITE ? WRITE : READ));
121	121	if ( rc == -1 ) {
122	122	PRINT_ERROR ("ERROR: port_associate: fd %d: %s\n", fd,
…	…
223	223
224	224	switch (rw) {
225		case 0:
	225	case FDPOLL_MODE_READ:
226	226	events &= (POLL_READ \| POLL_ERROR);
227	227	break;
228		case 1:
	228	case FDPOLL_MODE_WRITE:
229	229	events &= (POLL_WRITE \| POLL_ERROR);
230	230	break;
…	…
250	250	PORT_SOURCE_FD,
251	251	fd,
252		~~rw ? POLLOUT : POLLIN~~,
253		~~rw ? WRITE : READ~~);
	252	(rw == FDPOLL_MODE_WRITE ? POLLOUT : POLLIN),
	253	(rw == FDPOLL_MODE_WRITE ? WRITE : READ));
254	254	if ( rc == -1 ) {
255	255	PRINT_ERROR ("ERROR: port_associate: fd %d: %s\n", fd,

cherokee/trunk/cherokee/fdpoll-select.c

r703	r731
39	39	# define INFTIM -1
40	40	#endif
41
42		~~typedef enum {~~
43		~~fdp_read = 0,~~
44		~~fdp_write = 1~~
45		~~} cherokee_fdpoll_rw_t;~~
46	41
47	42
…	…
105	100	fdp->select_fds[nfd->npollfds] = fd;
106	101	switch (rw) {
107		case ~~fdp_read:~~
	102	case FDPOLL_MODE_READ:
108	103	FD_SET (fd, &fdp->master_rfdset);
109	104	break;
110		case ~~fdp_write:~~
	105	case FDPOLL_MODE_WRITE:
111	106	FD_SET (fd, &fdp->master_wfdset);
112	107	break;
…	…
172	167	{
173	168	switch (fdp->fd_rw[fd]) {
174		case ~~fdp_read:~~
	169	case FDPOLL_MODE_READ:
175	170	return FD_ISSET (fd, &fdp->working_rfdset);
176		case ~~fdp_write:~~
	171	case FDPOLL_MODE_WRITE:
177	172	return FD_ISSET (fd, &fdp->working_wfdset);
178	173	}

cherokee/trunk/cherokee/fdpoll-win32.c

r703	r731
35	35	# define INFTIM -1
36	36	#endif
37
38		~~typedef enum {~~
39		~~fdp_read = 0,~~
40		~~fdp_write = 1~~
41		~~} cherokee_fdpoll_rw_t;~~
42	37
43	38
…	…
96	91	fdp->select_fds[nfd->npollfds] = fd;
97	92	switch (rw) {
98		case ~~fdp_read:~~
	93	case FDPOLL_MODE_READ:
99	94	FD_SET (fd, &fdp->master_rfdset);
100	95	break;
101		case ~~fdp_write:~~
	96	case FDPOLL_MODE_WRITE:
102	97	FD_SET (fd, &fdp->master_wfdset);
103	98	break;
…	…
160	155	{
161	156	switch (rw) {
162		case ~~fdp_read:~~
	157	case FDPOLL_MODE_READ:
163	158	return FD_ISSET (fd, &fdp->working_rfdset);
164		case ~~fdp_write:~~
	159	case FDPOLL_MODE_WRITE:
165	160	return FD_ISSET (fd, &fdp->working_wfdset);
166	161	}

cherokee/trunk/cherokee/fdpoll.h

r702	r731
35	35	CHEROKEE_BEGIN_DECLS
36	36
	37	#define FDPOLL_MODE_NONE (-1) /* no mode set */
	38	#define FDPOLL_MODE_READ 0 /* poll read side */
	39	#define FDPOLL_MODE_WRITE 1 /* poll write side */
	40
37	41	typedef enum {
38	42	cherokee_poll_epoll,

cherokee/trunk/cherokee/macros.h

r718	r731
103	103	#define MIN_SPARE_FDS 10 /* range: 8 - 20 */
104	104	#define MIN_MAX_FDS 4 /* range: 4 ... 32000 */
	105	#define MIN_THR_FDS 4 /* range: 4 ... 32000 */
105	106
106	107	#if (MIN_SYSTEM_FD_NUM < 16)
…	…
112	113	#if (MIN_MAX_FDS < 4)
113	114	#error MIN_MAX_FDS too low, < 4 !
	115	#endif
	116	#if (MIN_THR_FDS < 4)
	117	#error MIN_THR_FDS too low, < 4 !
	118	#endif
	119	#if (MIN_THR_FDS > MIN_MAX_FDS)
	120	#error MIN_THR_FDS too high, > MIN_MAX_FDS !
114	121	#endif
115	122	#if (((MIN_SYSTEM_FD_NUM - MIN_SPARE_FDS) / 2) < MIN_MAX_FDS)

cherokee/trunk/cherokee/server.c

r723	r731
691	691	#ifdef AF_LOCAL
692	692	if (! cherokee_buffer_is_empty (&srv->unix_socket)) {
693		ret = initialize_server_socket_unix (srv, socket, port);
	693	ret = initialize_server_socket_unix (srv, socket, port);
694	694	}
695	695	#endif
…	…
738	738	{
739	739	ret_t ret;
740		int i, fds_per_thread;
	740	int i, fds_per_thread, fds_per_thread1;
741	741	#ifdef HAVE_PTHREAD
742	742	int thr_fds, spare_fds;
…	…
750	750	/* Set fd upper limit for threads.
751	751	*/
752		if (srv->thread_num > srv->max_fds)
753		srv->thread_num = srv->max_fds;
754		else
	752	#ifdef HAVE_PTHREAD
	753	if (srv->thread_num > (srv->max_fds / MIN_THR_FDS))
	754	srv->thread_num = (srv->max_fds / MIN_THR_FDS);
	755
755	756	if (srv->thread_num < 1)
756	757	srv->thread_num = 1;
757
	758	#else
	759	srv->thread_num = 1;
	760	#endif
758	761	fds_per_thread = srv->max_fds / srv->thread_num;
759	762	#ifdef HAVE_PTHREAD
…	…
761	764	spare_fds = srv->max_fds - thr_fds;
762	765	#endif
	766	fds_per_thread1 = fds_per_thread;
	767	if (spare_fds > 0) {
	768	spare_fds--;
	769	fds_per_thread1++;
	770	}
763	771
764	772	/* Create the main thread
765	773	*/
766	774	ret = cherokee_thread_new (&srv->main_thread, srv, thread_sync,
767		srv->fdpoll_method, srv->system_fd_limit, fds_per_thread);
768		if (unlikely(ret < ret_ok)) return ret;
	775	srv->fdpoll_method, srv->system_fd_limit, fds_per_thread1);
	776	if (unlikely(ret < ret_ok))
	777	return ret;
769	778
770	779	/* If Cherokee is compiled in single thread mode, it has to
…	…
772	781	*/
773	782	#ifndef HAVE_PTHREAD
774		ret = cherokee_fdpoll_add (srv->main_thread->fdpoll, S_SOCKET_FD(srv->socket), 0);
	783	ret = cherokee_fdpoll_add (srv->main_thread->fdpoll, S_SOCKET_FD(srv->socket), FDPOLL_MODE_READ);
775	784	if (unlikely(ret < ret_ok)) return ret;
776	785
777	786	if (srv->tls_enabled) {
778		ret = cherokee_fdpoll_add (srv->main_thread->fdpoll, S_SOCKET_FD(srv->socket_tls), 0);
	787	ret = cherokee_fdpoll_add (srv->main_thread->fdpoll, S_SOCKET_FD(srv->socket_tls), FDPOLL_MODE_READ);
779	788	if (unlikely(ret < ret_ok)) return ret;
780	789	}
…	…
787	796	for (i = 0; i < srv->thread_num - 1; i++) {
788	797	cherokee_thread_t *thread;
789		~~int fds_per_thread1 = fds_per_thread;~~
790	798
791	799	/* Add one more fd to this thread,
…	…
794	802	* unused fds.
795	803	*/
	804	fds_per_thread1 = fds_per_thread;
796	805	if (spare_fds > 0) {
797	806	spare_fds--;
…	…
801	810	ret = cherokee_thread_new (&thread, srv, thread_async,
802	811	srv->fdpoll_method, srv->system_fd_limit, fds_per_thread1);
803		if (unlikely(ret < ret_ok)) return ret;
	812	if (unlikely(ret < ret_ok))
	813	return ret;
804	814
805		thread->thread_pref = (i % 2)? thread_normal_tls : thread_tls_normal;
	815	thread->thread_pref = (i % 2) ? thread_normal_tls : thread_tls_normal;
806	816
807	817	cherokee_list_add (LIST(thread), &srv->thread_list);
…	…
1009	1019	srv->thread_num = srv->ncpus * 5;
1010	1020	}
1011		if (srv->thread_num > srv->max_fds) {
1012		srv->thread_num = srv->max_fds;
	1021	/* Limit the number of threads
	1022	* so that each thread has at least 2 fds available.
	1023	*/
	1024	if (srv->thread_num > (srv->max_fds / MIN_THR_FDS)) {
	1025	srv->thread_num = (srv->max_fds / MIN_THR_FDS);
1013	1026	if (srv->thread_num < 1)
1014	1027	srv->thread_num = 1;

cherokee/trunk/cherokee/thread.c

r706	r731
80	80	/* Has it changed?
81	81	*/
82		if (thd->bogo_now == srv->bogo_now) return;
	82	if (thd->bogo_now == srv->bogo_now)
	83	return;
83	84
84	85	/* Update time_t
85	86	*/
86	87	thd->bogo_now = srv->bogo_now;
87
	88
88	89	/* Update struct tm
89	90	*/
…	…
1375	1376	TRACE (ENTRIES, "error accepting connection! fd %d\n", srv_socket);
1376	1377
1377		/* New socket has alread been closed,
	1378	/* New socket has already been closed,
1378	1379	* so here we reinit fd to default init value.
1379	1380	*/
…	…
1486	1487	CHEROKEE_MUTEX_LOCK (mutex);
1487	1488
1488		ret = cherokee_fdpoll_add (thd->fdpoll, socket, 0);
	1489	ret = cherokee_fdpoll_add (thd->fdpoll, socket, FDPOLL_MODE_READ);
1489	1490	if (unlikely (ret < ret_ok)) {
1490	1491	CHEROKEE_MUTEX_UNLOCK (mutex);
…	…
1534	1535	/* Now, it owns the socket..
1535	1536	*/
1536		ret = cherokee_fdpoll_add (thd->fdpoll, socket, 0);
	1537	ret = cherokee_fdpoll_add (thd->fdpoll, socket, FDPOLL_MODE_READ);
1537	1538	if (unlikely (ret < ret_ok)) {
1538	1539	CHEROKEE_MUTEX_UNLOCK (mutex);
…	…
1572	1573	unlock = CHEROKEE_MUTEX_TRY_LOCK (mutex);
1573	1574	if (!unlock) {
1574		ret = cherokee_fdpoll_add (thd->fdpoll, socket, 0);
	1575	ret = cherokee_fdpoll_add (thd->fdpoll, socket, FDPOLL_MODE_READ);
1575	1576	if (ret < ret_ok) {
1576	1577	goto error;
…	…
1584	1585	unlock_tls = CHEROKEE_MUTEX_TRY_LOCK (mutex_tls);
1585	1586	if (!unlock_tls) {
1586		ret = cherokee_fdpoll_add (thd->fdpoll, socket_tls, 0);
	1587	ret = cherokee_fdpoll_add (thd->fdpoll, socket_tls, FDPOLL_MODE_READ);
1587	1588	if (unlikely (ret < ret_ok))
1588	1589	goto error;
…	…
1666	1667	CHEROKEE_MUTEX_LOCK (mutex1);
1667	1668
1668		ret = cherokee_fdpoll_add (thd->fdpoll, socket1, 0);
	1669	ret = cherokee_fdpoll_add (thd->fdpoll, socket1, FDPOLL_MODE_READ);
1669	1670	if (ret < ret_ok) {
1670	1671	CHEROKEE_MUTEX_UNLOCK (mutex1);
…	…
1679	1680	unlock2 = CHEROKEE_MUTEX_TRY_LOCK (mutex2);
1680	1681	if (!unlock2) {
1681		ret = cherokee_fdpoll_add (thd->fdpoll, socket2, 0);
	1682	ret = cherokee_fdpoll_add (thd->fdpoll, socket2, FDPOLL_MODE_READ);
1682	1683	if (ret < ret_ok) {
1683	1684	CHEROKEE_MUTEX_UNLOCK (mutex1);
…	…
1857	1858	ret_t ret;
1858	1859
1859		ret = cherokee_fdpoll_add (thd->fdpoll, SOCKET_FD(&conn->socket), 0);
	1860	ret = cherokee_fdpoll_add (thd->fdpoll, SOCKET_FD(&conn->socket), FDPOLL_MODE_READ);
1860	1861	if (unlikely (ret < ret_ok)) return ret;
1861	1862
…	…
2012	2013	cherokee_thread_inject_active_connection (cherokee_thread_t thd, cherokee_connection_t conn)
2013	2014	{
2014		cherokee_fdpoll_add (thd->fdpoll, SOCKET_FD(&conn->socket), 1);
	2015	cherokee_fdpoll_add (thd->fdpoll, SOCKET_FD(&conn->socket), FDPOLL_MODE_WRITE);
2015	2016	add_connection (thd, conn);
2016	2017

Navigation

Changeset 731

Legend: