acl 3.0.16 版本发布！

该版本主要优化了线程池调度的性能，同时优化了多线程事件引擎的效率

changes.txt

@@ -1,5 +1,6 @@
 �޸���ʷ�б���
 ------------------------------------------------------------------------
+66) 2014.2.17 --- acl 3.0.16 �汾������
 65) 2014.1.25 --- acl 3.0.15 �汾������
 64) 2014.1.11
 64.1) ��������� VC2008 ��֧��

lib_acl/changes.txt

@@ -1,6 +1,11 @@
 �޸���ʷ�б���
+
 ------------------------------------------------------------------------
 
+426) 2014.2.17
+426.1) feature: acl_event.c ���Ӻ��� acl_event_set_check_inter����������
+�����¼�ѭ�����̽���ȫ�������ּ���ʱ����
+
 425) 2014.2.14
 425.1) performance: acl_pthread_pool.c���� pthread_cond_signal ����
 pthread_mutex_unlock ֮�󣬴Ӷ����������̵߳ȴ����񱻴�����ʱ��(Ϊ�˷�ֹ
@@ -47,6 +52,8 @@ acl_aio_server.c, acl_udp_server.c 
 Ϊÿ���߳�һ���������߳������������Ӷ��������߳�֮�������ͻ����������
 �̳߳ص���������
 
+------------------------------------------------------------------------
+
 415) 2014.1.11
 415.1) compile: ȥ���� ACL_MS_WINDOWS �궨�壬��WINDOWS������ͳһʹ�� WIN32
 ����ʶ VC ���뻷��

lib_acl/include/event/acl_events.h

@@ -147,11 +147,25 @@ ACL_API HWND acl_event_wmsg_hwnd(ACL_EVENT *eventp);
  */
 ACL_API void acl_event_add_dog(ACL_EVENT *eventp);
 
-ACL_API void acl_event_fire_hook(ACL_EVENT *eventp,
+/**
+ * 设置事件触发的前置和后置处理过程
+ * @param eventp {ACL_EVENT*} 事件对象指针, 不为能为空
+ * @param fire_begin {void (*)(ACL_EVENT*, void*)} 当事件被统一触发前的回调过程
+ * @param fire_end {void (*)(ACL_EVENT*, void*)} 当事件被统一触发后的回调过程
+ * @param ctx {void*} fire_begin / fire_end 的第二个参数
+ */
+ACL_API void acl_event_set_fire_hook(ACL_EVENT *eventp,
 		void (*fire_begin)(ACL_EVENT*, void*),
 		void (*fire_end)(ACL_EVENT*, void*),
 		void* ctx);
 
+/**
+ * 设置事件循环过程中定时检查所有描述字状态的时间间隔，内部缺少值为 100 ms
+ * @param eventp {ACL_EVENT*} 事件对象指针, 不为能为空
+ * @param n {int} 定时查检时间间隔 (毫秒级)
+ */
+ACL_API void acl_event_set_check_inter(ACL_EVENT *eventp, int n);
+
 /**
  * 释放事件结构
  * @param eventp {ACL_EVENT*} 事件对象指针, 不为能为空

lib_acl/include/master/acl_threads_params.h

@@ -116,6 +116,14 @@ extern int   acl_var_threads_schedule_warn;
 #define	ACL_DEF_THREADS_SCHEDULE_WAIT		50
 extern int   acl_var_threads_schedule_wait;
 
+#define	ACL_VAR_THREADS_CHECK_INTER		"ioctl_check_inter"
+#define	ACL_DEF_THREADS_CHECK_INTER		100
+extern int   acl_var_threads_check_inter;
+
+#define	ACL_VAR_THREADS_QLEN_WARN		"ioctl_qlen_warn"
+#define	ACL_DEF_THREADS_QLEN_WARN		0
+extern int   acl_var_threads_qlen_warn;
+
 #endif /* ACL_UNIX */
 
 #ifdef	__cplusplus

lib_acl/src/event/acl_events.c

@@ -45,16 +45,14 @@ static void event_init(ACL_EVENT *eventp, int fdsize,
 
 	eventp->delay_sec  = delay_sec + delay_usec / 1000000;
 	eventp->delay_usec = delay_usec % 1000000;
-	/*
-	acl_ring_init(&eventp->used_ring);
-	acl_ring_init(&eventp->slot_ring);
-	*/
 
 	acl_ring_init(&eventp->timer_head);
 	eventp->timer_keep = 0;
 	SET_TIME(eventp->present);
 	SET_TIME(eventp->last_debug);
 
+	eventp->check_inter = 100000;  /* default: 100 ms */
+
 	if (eventp->init_fn)
 		eventp->init_fn(eventp);
 }
@@ -214,18 +212,21 @@ ACL_EVENT *acl_event_new_wmsg(unsigned int nMsg)
 #endif
 }
 
-ACL_EVENT *acl_event_new(int event_mode, int use_thr, int delay_sec, int delay_usec)
+ACL_EVENT *acl_event_new(int event_mode, int use_thr,
+	int delay_sec, int delay_usec)
 {
 	const char *myname = "acl_event_new";
 	ACL_EVENT *eventp = NULL;
 
 	if (use_thr) {
 		switch (event_mode) {
 		case ACL_EVENT_SELECT:
-			eventp = acl_event_new_select_thr(delay_sec, delay_usec);
+			eventp = acl_event_new_select_thr(delay_sec,
+					delay_usec);
 			break;
 		case ACL_EVENT_KERNEL:
-			eventp = acl_event_new_kernel_thr(delay_sec, delay_usec);
+			eventp = acl_event_new_kernel_thr(delay_sec,
+					delay_usec);
 			break;
 		case ACL_EVENT_POLL:
 			eventp = acl_event_new_poll_thr(delay_sec, delay_usec);
@@ -260,7 +261,13 @@ ACL_EVENT *acl_event_new(int event_mode, int use_thr, int delay_sec, int delay_u
 	return eventp;
 }
 
-void acl_event_fire_hook(ACL_EVENT *eventp, void (*fire_begin)(ACL_EVENT*, void*),
+void acl_event_set_check_inter(ACL_EVENT *eventp, int n)
+{
+	eventp->check_inter = n * 1000;
+}
+
+void acl_event_set_fire_hook(ACL_EVENT *eventp,
+	void (*fire_begin)(ACL_EVENT*, void*),
 	void (*fire_end)(ACL_EVENT*, void*), void* ctx)
 {
 	eventp->fire_begin = fire_begin;
@@ -282,6 +289,7 @@ void acl_event_free(ACL_EVENT *eventp)
 		acl_ring_detach(&timer->ring);
 		acl_myfree(timer);
 	}
+
 	acl_myfree(eventp->fdtabs);
 	acl_myfree(eventp->fdtabs_ready);
 	free_fn(eventp);
@@ -300,7 +308,8 @@ void acl_event_enable_read(ACL_EVENT *eventp, ACL_VSTREAM *stream,
 	if (sockfd == ACL_SOCKET_INVALID)
 		acl_msg_fatal("%s(%d): sockfd(%d) invalid",
 			myname, __LINE__, sockfd);
-	eventp->enable_read_fn(eventp, stream, read_timeout, callback, context);
+	eventp->enable_read_fn(eventp, stream, read_timeout,
+			callback, context);
 }
 
 void acl_event_enable_write(ACL_EVENT *eventp, ACL_VSTREAM *stream,
@@ -311,13 +320,15 @@ void acl_event_enable_write(ACL_EVENT *eventp, ACL_VSTREAM *stream,
 	if (sockfd == ACL_SOCKET_INVALID)
 		acl_msg_fatal("%s(%d): sockfd(%d) invalid",
 			myname, __LINE__, sockfd);
-	eventp->enable_write_fn(eventp, stream, write_timeout, callback, context);
+	eventp->enable_write_fn(eventp, stream, write_timeout,
+			callback, context);
 }
 
 void acl_event_enable_listen(ACL_EVENT *eventp, ACL_VSTREAM *stream,
 	int read_timeout, ACL_EVENT_NOTIFY_RDWR callback, void *context)
 {
-	eventp->enable_listen_fn(eventp, stream, read_timeout, callback, context);
+	eventp->enable_listen_fn(eventp, stream, read_timeout,
+			callback, context);
 }
 
 void acl_event_disable_read(ACL_EVENT *eventp, ACL_VSTREAM *stream)

lib_acl/src/event/events.h

@@ -80,6 +80,7 @@ struct	ACL_EVENT {
 	/* 当前时间截(微秒级) */
 	acl_int64 present;
 	acl_int64 last_check;
+	acl_int64 check_inter;
 	acl_int64 last_debug;
 	/* 事件引擎的最大等待时间(秒) */
 	int   delay_sec;

lib_acl/src/event/events_epoll_thr.c

@@ -343,7 +343,7 @@ static void event_loop(ACL_EVENT *eventp)
 
 	eventp->fdcnt_ready = 0;
 
-	if (eventp->present - eventp->last_check >= 100000) {
+	if (eventp->present - eventp->last_check >= eventp->check_inter) {
 		eventp->last_check = eventp->present;
 
 		THREAD_LOCK(&event_thr->event.tb_mutex);
@@ -371,7 +371,7 @@ static void event_loop(ACL_EVENT *eventp)
 
 	if (nready < 0) {
 		if (acl_last_error() != ACL_EINTR)
-			acl_msg_fatal("%s(%d), %s: event_loop: select: %s",
+			acl_msg_fatal("%s(%d), %s: event_loop: epoll: %s",
 				__FILE__, __LINE__, myname, acl_last_serror());
 		goto TAG_DONE;
 	} else if (nready == 0)

lib_acl/src/event/events_kernel.c

@@ -592,7 +592,7 @@ static void event_set_all(ACL_EVENT *eventp)
 
 	eventp->fdcnt_ready = 0;
 
-	if (eventp->present - eventp->last_check >= 100000) {
+	if (eventp->present - eventp->last_check >= eventp->check_inter) {
 		eventp->last_check = eventp->present;
 		event_check_fds(eventp);
 	}

lib_acl/src/event/events_poll_thr.c

@@ -153,9 +153,9 @@ static void event_enable_listen(ACL_EVENT *eventp, ACL_VSTREAM *stream,
 	if (eventp->maxfd == ACL_SOCKET_INVALID || eventp->maxfd < sockfd)
 		eventp->maxfd = sockfd;
 
-	acl_fdmap_add(event_thr->fdmap, sockfd, fdp);
-
 	THREAD_UNLOCK(&event_thr->event.tb_mutex);
+
+	acl_fdmap_add(event_thr->fdmap, sockfd, fdp);
 }
 
 static void event_enable_write(ACL_EVENT *eventp, ACL_VSTREAM *stream,
@@ -261,10 +261,10 @@ static void event_disable_readwrite(ACL_EVENT *eventp, ACL_VSTREAM *stream)
 		event_thr->fds[fdp->fdidx] = event_thr->fds[eventp->fdcnt];
 	}
 
-	THREAD_UNLOCK(&event_thr->event.tb_mutex);
-
 	acl_fdmap_del(event_thr->fdmap, sockfd);
 
+	THREAD_UNLOCK(&event_thr->event.tb_mutex);
+
 	if (fdp->flag & EVENT_FDTABLE_FLAG_READ)
 		stream->nrefer--;
 	if (fdp->flag & EVENT_FDTABLE_FLAG_WRITE)
@@ -314,24 +314,25 @@ static void event_loop(ACL_EVENT *eventp)
 	ACL_EVENT_NOTIFY_TIME timer_fn;
 	ACL_EVENT_TIMER *timer;
 	void *timer_arg;
-	int   delay, nready, i, revents;
+	int   delay, nready, i, revents, fdcnt;
 	ACL_EVENT_FDTABLE *fdp;
 
 	acl_ring_init(&timer_ring);
 
 	delay = eventp->delay_sec * 1000 + eventp->delay_usec / 1000;
-	if (delay <= 0)
+	if (delay < 0)
 		delay = 100; /* 100 milliseconds at least */
 
 	SET_TIME(eventp->present);
 	THREAD_LOCK(&event_thr->event.tm_mutex);
 
 	/*
-	 * Find out when the next timer would go off. Timer requests are sorted.
-	 * If any timer is scheduled, adjust the delay appropriately.
+	 * Find out when the next timer would go off. Timer requests
+	 * are sorted. If any timer is scheduled, adjust the delay
+	 * appropriately.
 	 */
 	if ((timer = ACL_FIRST_TIMER(&eventp->timer_head)) != 0) {
-		int   n = (int) (timer->when - eventp->present + 1000000 - 1)
+		int n = (int) (timer->when - eventp->present + 1000000 - 1)
 			/ 1000000;
 		if (n <= 0)
 			delay = 0;
@@ -343,12 +344,13 @@ static void event_loop(ACL_EVENT *eventp)
 
 	eventp->fdcnt_ready = 0;
 
-	if (eventp->present - eventp->last_check >= 100000) {
+	if (eventp->present - eventp->last_check >= eventp->check_inter) {
 		eventp->last_check = eventp->present;
 
 		THREAD_LOCK(&event_thr->event.tb_mutex);
 
 		if (event_thr_prepare(eventp) == 0) {
+
 			THREAD_UNLOCK(&event_thr->event.tb_mutex);
 
 			if (eventp->fdcnt_ready == 0)
@@ -358,7 +360,9 @@ static void event_loop(ACL_EVENT *eventp)
 			goto TAG_DONE;
 		}
 
-		memcpy(event_thr->fdset, event_thr->fds, eventp->fdcnt);
+		memcpy(event_thr->fdset, event_thr->fds,
+			eventp->fdcnt * sizeof(struct pollfd));
+		fdcnt = eventp->fdcnt;
 
 		THREAD_UNLOCK(&event_thr->event.tb_mutex);
 
@@ -367,24 +371,26 @@ static void event_loop(ACL_EVENT *eventp)
 	} else {
 		THREAD_LOCK(&event_thr->event.tb_mutex);
 
-		memcpy(event_thr->fdset, event_thr->fds, eventp->fdcnt);
+		memcpy(event_thr->fdset, event_thr->fds,
+			eventp->fdcnt * sizeof(struct pollfd));
+		fdcnt = eventp->fdcnt;
 
 		THREAD_UNLOCK(&event_thr->event.tb_mutex);
 	}
 
 	event_thr->event.blocked = 1;
-	nready = poll(event_thr->fdset, eventp->fdcnt, delay);
+	nready = poll(event_thr->fdset, fdcnt, delay);
 	event_thr->event.blocked = 0;
 
 	if (nready < 0) {
 		if (acl_last_error() != ACL_EINTR)
-			acl_msg_fatal("%s(%d), %s: event_loop: select: %s",
+			acl_msg_fatal("%s(%d), %s: event_loop: poll: %s",
 				__FILE__, __LINE__, myname, acl_last_serror());
 		goto TAG_DONE;
 	} else if (nready == 0)
 		goto TAG_DONE;
 
-	for (i = 0; i < eventp->fdcnt; i++) {
+	for (i = 0; i < fdcnt; i++) {
 		fdp = acl_fdmap_ctx(event_thr->fdmap, event_thr->fdset[i].fd);
 		if (fdp == NULL || fdp->stream == NULL)
 			continue;

lib_acl/src/init/acl_init.c

@@ -24,7 +24,7 @@
 
 #include "init.h"
 
-static char *version = "lib_acl_3.0.12";
+static char *version = "lib_acl_3.0.16";
 
 const char *acl_version(void)
 {

lib_acl/src/master/template/acl_threads_server.c

@@ -79,6 +79,8 @@ int   acl_var_threads_enable_core;
 int   acl_var_threads_max_debug;
 int   acl_var_threads_status_notify;
 int   acl_var_threads_batadd;
+int   acl_var_threads_check_inter;
+int   acl_var_threads_qlen_warn;
 int   acl_var_threads_schedule_warn;
 int   acl_var_threads_schedule_wait;
 
@@ -101,8 +103,10 @@ static ACL_CONFIG_INT_TABLE __conf_int_tab[] = {
 	{ ACL_VAR_THREADS_MAX_DEBUG, ACL_DEF_THREADS_MAX_DEBUG, &acl_var_threads_max_debug, 0, 0 },
 	{ ACL_VAR_THREADS_STATUS_NOTIFY, ACL_DEF_THREADS_STATUS_NOTIFY, &acl_var_threads_status_notify, 0, 0 },
 	{ ACL_VAR_THREADS_BATADD, ACL_DEF_THREADS_BATADD, &acl_var_threads_batadd, 0, 0 },
+	{ ACL_VAR_THREADS_QLEN_WARN, ACL_DEF_THREADS_QLEN_WARN, &acl_var_threads_qlen_warn, 0, 0 },
 	{ ACL_VAR_THREADS_SCHEDULE_WARN, ACL_DEF_THREADS_SCHEDULE_WARN, &acl_var_threads_schedule_warn, 0, 0 },
 	{ ACL_VAR_THREADS_SCHEDULE_WAIT, ACL_DEF_THREADS_SCHEDULE_WAIT, &acl_var_threads_schedule_wait, 0, 0 },
+	{ ACL_VAR_THREADS_CHECK_INTER, ACL_DEF_THREADS_CHECK_INTER, &acl_var_threads_check_inter, 0, 0 },
 
         { 0, 0, 0, 0, 0 },
 };
@@ -741,9 +745,16 @@ static ACL_EVENT *event_open(int event_mode, acl_pthread_pool_t *threads)
 
 	/* set the event fire begin and fire end callback */
 	if (acl_var_threads_batadd)
-		acl_event_fire_hook(event, event_fire_begin,
+		acl_event_set_fire_hook(event, event_fire_begin,
 			event_fire_end, threads);
 
+	if (acl_var_threads_check_inter > 0)
+		acl_event_set_check_inter(event, acl_var_threads_check_inter);
+
+	if (acl_var_threads_qlen_warn > 0)
+		acl_pthread_pool_set_qlen_warn(threads,
+			acl_var_threads_qlen_warn);
+
 	/*
 	 * Running as a semi-resident server. Service connection requests.
 	 * Terminate when we have serviced a sufficient number of clients,