Libevent-2.1.8源码分析——event_base（二）

1. 简介

上一节中，我们学习了如何创建一个默认的event_base。但是在实际的应用中，默认的event_base是远远满足不了需求的。更多的时候我们是需要根据具体的使用情况，来建立一个复杂的event_base。关于如何建立复杂的event_base，其实在上一篇章中，我们已经提及。接下来我们将更深入的了解如何建立一个复杂的event_base。

2. event_base_new_with_config

建立一个复杂的event_base需要将设置好的event_config传递给event_base_new_with_config，该函数返回我们所需要的event_base。

struct event_base *
event_base_new_with_config(const struct event_config *cfg)
{
	int i;
	struct event_base *base;
	int should_check_environment;

#ifndef EVENT__DISABLE_DEBUG_MODE
	event_debug_mode_too_late = 1;
#endif
	//调用内存管理函数分配event_base结构
	if ((base = mm_calloc(1, sizeof(struct event_base))) == NULL) {
		event_warn("%s: calloc", __func__);
		return NULL;
	}

	if (cfg)
		base->flags = cfg->flags;	//设置flags标志
	//判断是否需要检查EVENT_ * 环境变量
	should_check_environment =
	    !(cfg && (cfg->flags & EVENT_BASE_FLAG_IGNORE_ENV));

	{
		struct timeval tmp;
		int precise_time =
		    cfg && (cfg->flags & EVENT_BASE_FLAG_PRECISE_TIMER);	//是否设置了使用更精准的时间标志
		int flags;
		//如果没有设置使用更精准的时间标志，但是在环境变量中设置 使用更精准的时间那就设置标志
		if (should_check_environment && !precise_time) {
			precise_time = evutil_getenv_("EVENT_PRECISE_TIMER") != NULL;	//获取环境变量
			base->flags |= EVENT_BASE_FLAG_PRECISE_TIMER;
		}
		flags = precise_time ? EV_MONOT_PRECISE : 0;
		evutil_configure_monotonic_time_(&base->monotonic_timer, flags);	//配置是否使用更精准的时间

		gettime(base, &tmp);
	}
	//初始化超时时间优先级队列（最小堆）
	min_heap_ctor_(&base->timeheap);

	base->sig.ev_signal_pair[0] = -1;
	base->sig.ev_signal_pair[1] = -1;
	//初始化socketpair，用于唤醒event_base通过其他线程
	base->th_notify_fd[0] = -1;
	base->th_notify_fd[1] = -1;

	//初始化队列
	TAILQ_INIT(&base->active_later_queue);

	evmap_io_initmap_(&base->io);
	evmap_signal_initmap_(&base->sigmap);
	event_changelist_init_(&base->changelist);

	base->evbase = NULL;

	//下面的这操作用于根据event_config进行设定
	if (cfg) {
		memcpy(&base->max_dispatch_time,
		    &cfg->max_dispatch_interval, sizeof(struct timeval));
		base->limit_callbacks_after_prio =
		    cfg->limit_callbacks_after_prio;
	} else {
		base->max_dispatch_time.tv_sec = -1;
		base->limit_callbacks_after_prio = 1;
	}
	if (cfg && cfg->max_dispatch_callbacks >= 0) {
		base->max_dispatch_callbacks = cfg->max_dispatch_callbacks;
	} else {
		base->max_dispatch_callbacks = INT_MAX;
	}
	if (base->max_dispatch_callbacks == INT_MAX &&
	    base->max_dispatch_time.tv_sec == -1)
		base->limit_callbacks_after_prio = INT_MAX;

	//选择使用的后端方法
	for (i = 0; eventops[i] && !base->evbase; i++) {
		//根据event_config的配置，是否屏蔽某些后端或设置某项特征
		if (cfg != NULL) {
			/* determine if this backend should be avoided */
			if (event_config_is_avoided_method(cfg,
				eventops[i]->name))
				continue;
			if ((eventops[i]->features & cfg->require_features)
			    != cfg->require_features)
				continue;
		}
		//环境变量的设置
		/* also obey the environment variables */
		if (should_check_environment &&
		    event_is_method_disabled(eventops[i]->name))
			continue;
		//找到要使用的后端
		base->evsel = eventops[i];

		base->evbase = base->evsel->init(base);
	}
	//没找到可使用的后端，返回 NULL
	if (base->evbase == NULL) {
		event_warnx("%s: no event mechanism available",
		    __func__);
		base->evsel = NULL;
		event_base_free(base);
		return NULL;
	}

	if (evutil_getenv_("EVENT_SHOW_METHOD"))
		event_msgx("libevent using: %s", base->evsel->name);

	/* allocate a single active event queue */
	if (event_base_priority_init(base, 1) < 0) {
		event_base_free(base);
		return NULL;
	}

	/* prepare for threading */

#if !defined(EVENT__DISABLE_THREAD_SUPPORT) && !defined(EVENT__DISABLE_DEBUG_MODE)
	event_debug_created_threadable_ctx_ = 1;
#endif

#ifndef EVENT__DISABLE_THREAD_SUPPORT
	//使能了线程的支持
	if (EVTHREAD_LOCKING_ENABLED() &&
	    (!cfg || !(cfg->flags & EVENT_BASE_FLAG_NOLOCK))) {
		int r;
		EVTHREAD_ALLOC_LOCK(base->th_base_lock, 0);
		EVTHREAD_ALLOC_COND(base->current_event_cond);
		//用于初始化通知
		r = evthread_make_base_notifiable(base);
		if (r<0) {
			event_warnx("%s: Unable to make base notifiable.", __func__);
			event_base_free(base);
			return NULL;
		}
	}
#endif

#ifdef _WIN32
	if (cfg && (cfg->flags & EVENT_BASE_FLAG_STARTUP_IOCP))
		event_base_start_iocp_(base, cfg->n_cpus_hint);
#endif

	return (base);
}

2.1 evutil_configure_monotonic_time_

这个函数是用来配置使用时间精度精准或比较粗糙。通过是否设置了使用精准的时间标志选择。

int
evutil_configure_monotonic_time_(struct evutil_monotonic_timer *base,
    int flags)
{
	/* CLOCK_MONOTONIC exists on FreeBSD, Linux, and Solaris.  You need to
	 * check for it at runtime, because some older kernel versions won't
	 * have it working. */
#ifdef CLOCK_MONOTONIC_COARSE	//内核是否支持CLOCK_MONOTONIC_COARSE
	const int precise = flags & EV_MONOT_PRECISE;
#endif
	const int fallback = flags & EV_MONOT_FALLBACK;
	struct timespec	ts;

#ifdef CLOCK_MONOTONIC_COARSE
	//关于CLOCK_MONOTONIC_COARSE和POSIX中CLOCK_MONOTONIC类似，只不过是精度比较粗糙的版本
	if (CLOCK_MONOTONIC_COARSE < 0) {
		/* Technically speaking, nothing keeps CLOCK_* from being
		 * negative (as far as I know). This check and the one below
		 * make sure that it's safe for us to use -1 as an "unset"
		 * value. */
		event_errx(1,"I didn't expect CLOCK_MONOTONIC_COARSE to be < 0");
	}
	//如果flag设置使用精准的时间，那么是不会调用下面的
	if (! precise && ! fallback) {
		if (clock_gettime(CLOCK_MONOTONIC_COARSE, &ts) == 0) {
			base->monotonic_clock = CLOCK_MONOTONIC_COARSE;
			return 0;
		}
	}
#endif
	//CLOCK_MONOTONIC:从系统启动这一刻起开始计时,不受系统时间被用户改变的影响，方便用于两个事件的间隔
	if (!fallback && clock_gettime(CLOCK_MONOTONIC, &ts) == 0) {
		base->monotonic_clock = CLOCK_MONOTONIC;
		return 0;
	}

	if (CLOCK_MONOTONIC < 0) {
		event_errx(1,"I didn't expect CLOCK_MONOTONIC to be < 0");
	}

	base->monotonic_clock = -1;
	return 0;
}

2.2 gettime

这个函数用于获取一个timeval时间

/** Set 'tp' to the current time according to 'base'.  We must hold the lock
 * on 'base'.  If there is a cached time, return it.  Otherwise, use
 * clock_gettime or gettimeofday as appropriate to find out the right time.
 * Return 0 on success, -1 on failure.
 */
static int
gettime(struct event_base *base, struct timeval *tp)
{
	//如果使能调试锁，那么会断言event_base是否持有锁，这边要求必须持有锁，没有则断言失败
	EVENT_BASE_ASSERT_LOCKED(base);	
	//如果时间有了缓存，直接返回。避免过多的时间获取调用
	if (base->tv_cache.tv_sec) {
		*tp = base->tv_cache;
		return (0);
	}
	//会根据evutil_configure_monotonic_time_中设置的monotonic_clock 来选择是否
	//使用gettimeofday或clock_gettime获取得到tp
	if (evutil_gettime_monotonic_(&base->monotonic_timer, tp) == -1) {
		return -1;
	}
	//宏CLOCK_SYNC_INTERVAL定义为5，这里的意思是5s更新一次libevent内部时间不同（可能使用gettimeofday或clock_gettime）
	if (base->last_updated_clock_diff + CLOCK_SYNC_INTERVAL
	    < tp->tv_sec) {
		struct timeval tv;
		evutil_gettimeofday(&tv,NULL);
		evutil_timersub(&tv, tp, &base->tv_clock_diff);
		base->last_updated_clock_diff = tp->tv_sec;
	}

	return 0;
}

3. 使用范例

#include <stdio.h>
#include <string.h>
#include <event2/event-config.h>
#include <event2/event.h> 

//cc -I/usr/local/include -o test main.cpp -L/usr/local/lib -levent

int main(void)
{
	struct event_base *pBase;
	struct event_config *pConfig;

	pConfig = event_config_new();

	//设置event_base_config_flag：不检测环境变量和使用更精准的定时器
	event_config_set_flag(pConfig, EVENT_BASE_FLAG_IGNORE_ENV | EVENT_BASE_FLAG_PRECISE_TIMER);
	//告诉event_base不使用epoll和poll后端方法
	event_config_avoid_method(pConfig, "epoll");
	event_config_avoid_method(pConfig, "poll");
	//对后端的特性进行筛选
	event_config_require_features(pConfig, EV_FEATURE_FDS);
	//设置CPU数
	event_config_set_num_cpus_hint(pConfig, 1);
	//设置事件优先级相关的
	event_config_set_max_dispatch_interval(pConfig, NULL, -1, 0);

	pBase = event_base_new_with_config(pConfig);
	if (pBase == NULL)
	{
		fprintf(stderr, "event_base_new_with_config error!\r\n");
		event_config_free(pConfig);
		return 0;
	}

	const char *pCurrMethod = event_base_get_method(pBase);
	if (pCurrMethod != NULL)
		printf("Current method is %s\r\n", pCurrMethod);

	//do something...

	event_config_free(pConfig);
	
	event_base_dispatch(pBase);
	event_base_free(pBase);

	return 0;
}

在Linux上运行如下所示：

Current method is select