/*
* Set up a thread's information.
*/
static void setup_thread(LIBEVENT_THREAD *me) {
me->type = GENERAL;
me->base = event_base_new();
if (! me->base) {
settings.extensions.logger->log(EXTENSION_LOG_WARNING, NULL,
"Can't allocate event base\n");
exit(1);
}
/* Listen for notifications from other threads */
event_set(&me->notify_event, me->notify[0],
EV_READ | EV_PERSIST,
thread_libevent_process, me);
event_base_set(me->base, &me->notify_event);
if (event_add(&me->notify_event, 0) == -1) {
settings.extensions.logger->log(EXTENSION_LOG_WARNING, NULL,
"Can't monitor libevent notify pipe\n");
exit(1);
}
me->new_conn_queue = malloc(sizeof(struct conn_queue));
if (me->new_conn_queue == NULL) {
settings.extensions.logger->log(EXTENSION_LOG_WARNING, NULL,
"Failed to allocate memory for connection queue");
exit(EXIT_FAILURE);
}
cq_init(me->new_conn_queue);
cb_mutex_initialize(&me->mutex);
// Initialize threads' sub-document parser / handler
me->subdoc_op = subdoc_op_alloc();
}
/*
* Set up a thread's information.
*/
static void setup_thread(LIBEVENT_THREAD *me)
{
me->base = event_init();
if (! me->base)
{
log_debug(LOG_ERR, "Can't allocate event base\n");
exit(1);
}
/* Listen for notifications from other threads */
event_set(&me->notify_event, me->notify_receive_fd,
EV_READ | EV_PERSIST, thread_libevent_process, me);
event_base_set(me->base, &me->notify_event);
if (event_add(&me->notify_event, 0) == -1)
{
log_debug(LOG_ERR, "Can't monitor libevent notify pipe\n");
exit(1);
}
me->new_conn_queue = (conn_queue *)malloc(sizeof(struct conn_queue));
if (me->new_conn_queue == NULL)
{
log_debug(LOG_ERR, "Failed to allocate memory for connection queue, error:%s\n", strerror(errno));
exit(EXIT_FAILURE);
}
cq_init(me->new_conn_queue);
}
/*
* Set up a thread's information.
*/
static void setup_thread(LIBEVENT_THREAD *me) {
if (! me->base) {
me->base = event_init();
if (! me->base) {
moxi_log_write("Can't allocate event base\n");
exit(1);
}
}
/* Listen for notifications from other threads */
event_set(&me->notify_event, me->notify_receive_fd,
EV_READ | EV_PERSIST, thread_libevent_process, me);
event_base_set(me->base, &me->notify_event);
if (event_add(&me->notify_event, 0) == -1) {
moxi_log_write("Can't monitor libevent notify pipe\n");
exit(1);
}
me->new_conn_queue = malloc(sizeof(struct conn_queue));
if (me->new_conn_queue == NULL) {
perror("Failed to allocate memory for connection queue");
exit(EXIT_FAILURE);
}
cq_init(me->new_conn_queue);
// TODO: Merge new_conn_queue with work_queue.
//
me->work_queue = calloc(1, sizeof(work_queue));
if (me->work_queue == NULL) {
perror("Failed to allocate memory for work queue");
exit(EXIT_FAILURE);
}
work_queue_init(me->work_queue, me->base);
if (pthread_mutex_init(&me->stats.mutex, NULL) != 0) {
perror("Failed to initialize mutex");
exit(EXIT_FAILURE);
}
me->suffix_cache = cache_create("suffix", SUFFIX_SIZE, sizeof(char*),
NULL, NULL);
if (me->suffix_cache == NULL) {
moxi_log_write("Failed to create suffix cache\n");
exit(EXIT_FAILURE);
}
me->conn_hash = genhash_init(512, strhash_ops);
if (me->conn_hash == NULL) {
moxi_log_write("Failed to create connection hash\n");
exit(EXIT_FAILURE);
}
}
/*
* Set up a thread's information.
*/
static void setup_thread(LIBEVENT_THREAD *me) {
#if defined(LIBEVENT_VERSION_NUMBER) && LIBEVENT_VERSION_NUMBER >= 0x02000101
struct event_config *ev_config;
ev_config = event_config_new();
event_config_set_flag(ev_config, EVENT_BASE_FLAG_NOLOCK);
me->base = event_base_new_with_config(ev_config);
event_config_free(ev_config);
#else
me->base = event_init();
#endif
if (! me->base) {
fprintf(stderr, "Can't allocate event base\n");
exit(1);
}
/* Listen for notifications from other threads */
event_set(&me->notify_event, me->notify_receive_fd,
EV_READ | EV_PERSIST, thread_libevent_process, me);
event_base_set(me->base, &me->notify_event);
if (event_add(&me->notify_event, 0) == -1) {
fprintf(stderr, "Can't monitor libevent notify pipe\n");
exit(1);
}
me->new_conn_queue = malloc(sizeof(struct conn_queue));
if (me->new_conn_queue == NULL) {
perror("Failed to allocate memory for connection queue");
exit(EXIT_FAILURE);
}
cq_init(me->new_conn_queue);
if (pthread_mutex_init(&me->stats.mutex, NULL) != 0) {
perror("Failed to initialize mutex");
exit(EXIT_FAILURE);
}
me->suffix_cache = cache_create("suffix", SUFFIX_SIZE, sizeof(char*),
NULL, NULL);
if (me->suffix_cache == NULL) {
fprintf(stderr, "Failed to create suffix cache\n");
exit(EXIT_FAILURE);
}
#ifdef EXTSTORE
me->io_cache = cache_create("io", sizeof(io_wrap), sizeof(char*), NULL, NULL);
if (me->io_cache == NULL) {
fprintf(stderr, "Failed to create IO object cache\n");
exit(EXIT_FAILURE);
}
#endif
}
/*
* Set up a thread's information.
*/
static void setup_thread(LIBEVENT_THREAD *me, bool tap) {
me->type = tap ? TAP : GENERAL;
me->base = event_init();
if (! me->base) {
settings.extensions.logger->log(EXTENSION_LOG_WARNING, NULL,
"Can't allocate event base\n");
exit(1);
}
/* Listen for notifications from other threads */
event_set(&me->notify_event, me->notify[0],
EV_READ | EV_PERSIST,
tap ? libevent_tap_process : thread_libevent_process, me);
event_base_set(me->base, &me->notify_event);
if (event_add(&me->notify_event, 0) == -1) {
settings.extensions.logger->log(EXTENSION_LOG_WARNING, NULL,
"Can't monitor libevent notify pipe\n");
exit(1);
}
if (!tap) {
me->new_conn_queue = malloc(sizeof(struct conn_queue));
if (me->new_conn_queue == NULL) {
settings.extensions.logger->log(EXTENSION_LOG_WARNING, NULL,
"Failed to allocate memory for connection queue");
exit(EXIT_FAILURE);
}
cq_init(me->new_conn_queue);
}
if ((pthread_mutex_init(&me->mutex, NULL) != 0)) {
settings.extensions.logger->log(EXTENSION_LOG_WARNING, NULL,
"Failed to initialize mutex: %s\n",
strerror(errno));
exit(EXIT_FAILURE);
}
me->suffix_cache = cache_create("suffix", SUFFIX_SIZE, sizeof(char*),
NULL, NULL);
if (me->suffix_cache == NULL) {
settings.extensions.logger->log(EXTENSION_LOG_WARNING, NULL,
"Failed to create suffix cache\n");
exit(EXIT_FAILURE);
}
}
/*
* Set up a thread's information.
*/
static void setup_thread(LIBEVENT_THREAD *me) {
me->base = event_init();
if (! me->base) {
fprintf(stderr, "Can't allocate event base\n");
exit(1);
}
me->new_conn_queue = (struct conn_queue *)malloc(sizeof(struct conn_queue));
if (me->new_conn_queue == NULL) {
perror("Failed to allocate memory for connection queue");
exit(EXIT_FAILURE);
}
cq_init(me->new_conn_queue);
if (pthread_mutex_init(&me->stats.mutex, NULL) != 0) {
perror("Failed to initialize mutex");
exit(EXIT_FAILURE);
}
}
/*
* Set up a thread's information.
*/
static void setup_thread(LIBEVENT_THREAD *me) {
//初始化worker线程的libevent
me->base = event_init();
if (! me->base) {
fprintf(stderr, "Can't allocate event base\n");
exit(1);
}
/* Listen for notifications from other threads */
//设置事件，监听与主线程的通信，事件处理函数为thread_libevent_process
event_set(&me->notify_event, me->notify_receive_fd,
EV_READ | EV_PERSIST, thread_libevent_process, me);
event_base_set(me->base, &me->notify_event);
//将事件添加到libevent的事件循环中
if (event_add(&me->notify_event, 0) == -1) {
fprintf(stderr, "Can't monitor libevent notify pipe\n");
exit(1);
}
//创建一个空队列，用于接收主线程发送过来的CQ_ITEM
me->new_conn_queue = malloc(sizeof(struct conn_queue));
if (me->new_conn_queue == NULL) {
perror("Failed to allocate memory for connection queue");
exit(EXIT_FAILURE);
}
//初始化CQ_ITEM队列
cq_init(me->new_conn_queue);
if (pthread_mutex_init(&me->stats.mutex, NULL) != 0) {
perror("Failed to initialize mutex");
exit(EXIT_FAILURE);
}
me->suffix_cache = cache_create("suffix", SUFFIX_SIZE, sizeof(char*),
NULL, NULL);
if (me->suffix_cache == NULL) {
fprintf(stderr, "Failed to create suffix cache\n");
exit(EXIT_FAILURE);
}
}
/*
* Set up a thread's information.
*/
static void setup_thread(LIBEVENT_THREAD *me) {
if (! me->base) {
me->base = event_init();
if (! me->base) {
fprintf(stderr, "Can't allocate event base\n");
exit(1);
}
}
/* Listen for notifications from other threads */
event_set(&me->notify_event, me->notify_receive_fd,
EV_READ | EV_PERSIST, thread_libevent_process, me);
event_base_set(me->base, &me->notify_event);
if (event_add(&me->notify_event, 0) == -1) {
fprintf(stderr, "Can't monitor libevent notify pipe\n");
exit(1);
}
cq_init(&me->new_conn_queue);
}
/*
* Set up a thread's information.
*/
static void setup_thread(WORK_THREAD *me) {
me->loop = ev_loop_new(0);
if (! me->loop) {
fprintf(stderr, "Can't allocate event base\n");
exit(1);
}
me->async_watcher.data = me;
/* Listen for notifications from other threads */
ev_async_init(&me->async_watcher, async_cb);
ev_async_start(me->loop, &me->async_watcher);
me->new_conn_queue = malloc(sizeof(struct conn_queue));
if (me->new_conn_queue == NULL) {
perror("Failed to allocate memory for connection queue\n");
exit(EXIT_FAILURE);
}
cq_init(me->new_conn_queue);
}
/*
* Set up a thread's information.
*/
static void setup_thread(LIBEVENT_THREAD *me) {
me->base = event_init();
if (! me->base) {
fprintf(stderr, "Can't allocate event base\n");
exit(1);
}
#ifdef DUP_AWARE
event_priority_init(NUM_PRIORITIES);
#endif
/* Listen for notifications from other threads */
event_set(&me->notify_event, me->notify_receive_fd,
EV_READ | EV_PERSIST, thread_libevent_process, me);
event_base_set(me->base, &me->notify_event);
if (event_add(&me->notify_event, 0) == -1) {
fprintf(stderr, "Can't monitor libevent notify pipe\n");
exit(1);
}
me->new_conn_queue = malloc(sizeof(struct conn_queue));
if (me->new_conn_queue == NULL) {
perror("Failed to allocate memory for connection queue");
exit(EXIT_FAILURE);
}
cq_init(me->new_conn_queue);
if (pthread_mutex_init(&me->stats.mutex, NULL) != 0) {
perror("Failed to initialize mutex");
exit(EXIT_FAILURE);
}
me->suffix_cache = cache_create("suffix", SUFFIX_SIZE, sizeof(char*),
NULL, NULL);
if (me->suffix_cache == NULL) {
fprintf(stderr, "Failed to create suffix cache\n");
exit(EXIT_FAILURE);
}
}
/*
* Set up a thread's information.
*/
static void setup_thread(LIBEVENT_THREAD *me) {
me->base = event_init();
if (! me->base) {
fprintf(stderr, "Can't allocate event base\n");
exit(1);
}
/* Listen for notifications from other threads */
//为管道设置读事件监听，thread_libevent_process为回调函数
event_set(&me->notify_event, me->notify_receive_fd,
EV_READ | EV_PERSIST, thread_libevent_process, me);
event_base_set(me->base, &me->notify_event);
if (event_add(&me->notify_event, 0) == -1) {
fprintf(stderr, "Can't monitor libevent notify pipe\n");
exit(1);
}
//为新线程创建连接CQ链表
me->new_conn_queue = malloc(sizeof(struct conn_queue));
if (me->new_conn_queue == NULL) {
perror("Failed to allocate memory for connection queue");
exit(EXIT_FAILURE);
}
//初始化线程控制器内的CQ链表
cq_init(me->new_conn_queue);
if (pthread_mutex_init(&me->stats.mutex, NULL) != 0) {
perror("Failed to initialize mutex");
exit(EXIT_FAILURE);
}
//创建cache
me->suffix_cache = cache_create("suffix", SUFFIX_SIZE, sizeof(char*),
NULL, NULL);
if (me->suffix_cache == NULL) {
fprintf(stderr, "Failed to create suffix cache\n");
exit(EXIT_FAILURE);
}
}
void WorkerThreads::setup_event_thread(LIBEVENT_THREAD *me)
{
me->base=(event_base*)event_init();//every thread has its own event_base
//2.0 has event_config
/*
struct event_config *cfg=event_config_new();
event_config_avoid_method(cfg,"epoll");
me->base=event_base_new_with_config(cfg);
event_config_free(cfg);
*/
//in order to use libevent on file,use this method
if(!me->base)
{
fprintf(stderr,"can't allocate event base\n");
exit(1);
}
event_set(&me->notify_event,me->notify_receive_fd, //设置 监听事件 和 处理函数
EV_READ|EV_PERSIST, thread_libevent_process,me);
event_base_set(me->base,&me->notify_event);
if(event_add(&me->notify_event,0)==-1)
{
fprintf(stderr,"can't monitor libevent notify pipe\n");
exit(1);
}
//why initiate conn_queue here?
me->new_conn_queue=(conn_queue*)malloc(sizeof(struct conn_queue)); //内部的conn_queue
if(me->new_conn_queue==NULL)
{
perror("Failed to allocate memory for connection queue");
exit(EXIT_FAILURE);
}
cq_init(me->new_conn_queue);
}
int setup_thread(thread_cg * t_cg){
t_cg->base = event_init();
if(! t_cg->base){
fprintf(stderr, "can't alloc event base\n");
exit(1);
}
event_set(&t_cg->notify_event, t_cg->read_fd, EV_READ | EV_PERSIST, thread_libevent_process, t_cg);
event_base_set(t_cg->base, &t_cg->notify_event);
if (event_add(&t_cg->notify_event, 0) == -1)
{
fprintf(stderr, "Can't monitor libevent notify pipe\n");
exit(1);
}
t_cg->new_conn_queue = malloc(sizeof(struct conn_queue));
if (t_cg->new_conn_queue == NULL) {
perror("Failed to allocate memory for connection queue");
exit(EXIT_FAILURE);
}
cq_init(t_cg->new_conn_queue);
//未完成，应该还是需要实现连接管理的
}
static void setup_thread(LIBEVENT_THREAD *me) {
me->base = event_base_new();
if (NULL == me->base) {
mfatal("allocate event base failed!");
exit(1);
}
event_set(&me->notify_event, me->notify_receive_fd,
EV_READ | EV_PERSIST, thread_libevent_process, me);
event_base_set(me->base, &me->notify_event);
if (event_add(&me->notify_event, 0) == -1) {
mfatal("can't monitor libevent notify pipe!");
exit(1);
}
me->new_conn_queue = (struct conn_queue *)malloc(sizeof(struct conn_queue));
if (NULL == me->new_conn_queue) {
mfatal("connection queue alloc failed!");
exit(EXIT_FAILURE);
}
cq_init(me->new_conn_queue);
}
void print_levelbylevel(ptr_rbnode root) {
CircularQueue *cq;
cq_init(cq, ELEMENT_MAX);
cq_push(cq, root);
int depth_cnt = -1;
while ((depth_cnt = cq->capacity)) {
while (depth_cnt--) {
cq_element_t current_node = cq_front(cq);
cq_pop(cq);
if (current_node->nil) {
printf("N ");
}
else {
printf("%d%s ", current_node->val, current_node->color ? "(B)" : "(R)");
cq_push(cq, current_node->left);
cq_push(cq, current_node->right);
}
}
printf("\n");
}
cq_destroy(cq);
}
