处理大并发之四 libevent demo详细分析（对比epoll）

 

处理大并发之四 libevent demo详细分析（对比epoll）

分类： linux 网络编程 2013-07-18 20:07  2095人阅读  评论(1)  收藏  举报

大并发处理 libevent 服务端自己维护缓冲区

处理大并发之四 libevent demo详细分析（对比epoll）

libevent默认情况下是单线程，每个线程有且仅有一个event_base，对应一个struct event_base结构体，以及赋予其上的事件管理器，用来安排托管给它的一系列的事件。

当有一个事件发生的时候，event_base会在合适的时间去调用绑定在这个事件上的函数，直到这个函数执行完成，然后在返回安排其他事件。需要注意的是：合适的时间并不是立即。

例如：

 struct event_base *base;
 base = event_base_new();//初始化libevent

event_base_new对比epoll，可以理解为epoll里的epoll_create。

event_base内部有一个循环，循环阻塞在epoll调用上，当有一个事件发生的时候，才会去处理这个事件。其中，这个事件是被绑定在event_base上面的，每一个事件就会对应一个struct event，可以是监听的fd。 

其中struct event 使用event_new 来创建和绑定，使用event_add来启用，例如：

 struct event *listener_event;
 listener_event = event_new(base, listener, EV_READ|EV_PERSIST, do_accept, (void*)base);

参数说明：

base：event_base类型，event_base_new的返回值

listener：监听的fd，listen的fd

EV_READ|EV_PERSIST：事件的类型及属性

do_accept：绑定的回调函数

(void*)base：给回调函数的参数

event_add(listener_event, NULL);

对比epoll：

event_new相当于epoll中的epoll_wait，其中的epoll里的while循环，在libevent里使用event_base_dispatch。

event_add相当于epoll中的epoll_ctl，参数是EPOLL_CTL_ADD，添加事件。

注：libevent支持的事件及属性包括(使用bitfield实现，所以要用 | 来让它们合体)
EV_TIMEOUT: 超时
EV_READ: 只要网络缓冲中还有数据，回调函数就会被触发
EV_WRITE: 只要塞给网络缓冲的数据被写完，回调函数就会被触发
EV_SIGNAL: POSIX信号量
EV_PERSIST: 不指定这个属性的话，回调函数被触发后事件会被删除
EV_ET: Edge-Trigger边缘触发，相当于EPOLL的ET模式

事件创建添加之后，就可以处理发生的事件了，相当于epoll里的epoll_wait,在libevent里使用event_base_dispatch启动event_base循环，直到不再有需要关注的事件。

有了上面的分析，结合之前做的epoll服务端程序，对于一个服务器程序，流程基本是这样的：

1. 创建socket，bind，listen，设置为非阻塞模式

2. 创建一个event_base，即

 struct event_base *  event_base_new(void)

3. 创建一个event，将该socket托管给event_base，指定要监听的事件类型，并绑定上相应的回调函数(及需要给它的参数)。即

 struct event *  event_new(struct event_base *base, evutil_socket_t fd, short events, void (*cb)(evutil_socket_t, short, void *), void *arg)

4. 启用该事件，即

 int  event_add(struct event *ev, const struct timeval *tv)

5.  进入事件循环，即

 int  event_base_dispatch(struct event_base *event_base)

 

有了这些知识储备，来看下官网上的demo，网址：http://www.wangafu.net/~nickm/libevent-book/01_intro.html，这里引用的例子是Example: A low-level ROT13 server with Libevent

首先来翻译下例子上面的一段话：

对于select函数来说，不同的操作系统有不同的代替函数，它包括：poll,epoll,kqueue,evport和/dev/poll。这些函数的性能都比select要好，其中epoll在IO中添加，删除，通知socket准备好方面性能复杂度为O(1)。

不幸的是，没有一个有效的接口是一个普遍存在的标准，linux下有epoll，BSDS有kqueue，Solaris 有evport和/dev/poll，等等。没有任何一个操作系统有它们中所有的，所以如果你想做一个轻便的高性能的异步应用程序，你就需要把这些接口抽象的封装起来，并且无论哪一个系统使用它都是最高效的。

这对于你来说就是最低级的libevent API，它提供了统一的接口取代了select，当它在计算机上运行的时候，使用了最有效的版本。

这里是ROT13服务器的另外一个版本，这次，他使用了libevent代替了select。这意味着我们不再使用fd_sets，取而代之的使用event_base添加和删除事件，它可能在select，poll，epoll，kqueue等中执行。

代码分析：

这是一个服务端的程序，可以处理客户端大并发的连接，当收到客户端的连接后，将收到的数据做了一个变换，如果是 ’a’-‘m’之间的字符，将其增加13，如果是 ’n’-‘z’之间的字符，将其减少13，其他字符不变，然后将转换后的数据发送给客户端。

例如：客户端发送：Client 0 send  Message!

服务端会回复：Pyvrag 0 fraq  Zrffntr!

在这个代码中没有使用bufferevent这个强大的东西，在一个结构体中自己管理了一个缓冲区。结构体为：

 struct fd_state {
     char buffer[MAX_LINE];//缓冲区的大小
     size_t buffer_used;//接收到已经使用的buffer大小，每次将接收到的数据字节数相加，当发送的字节数累计相加和buffer_used都相等时候，将它们都置为1

     size_t n_written;//发送的累加字节数
     size_t write_upto;//相当于一个临时变量，当遇到换行符的时，将其收到的字节数（换行符除外）赋给该值，当检测到写事件的时候，用已经发送的字节数和该数值做比较，若收到的字节总数小于该值，则发送数据，等于该值，将结构体中3个字节数统计变量都置为1，为什么会置为1呢，因为有一个换行符吧。

     struct event *read_event;
     struct event *write_event;
 };

代码中自己管理了一个缓冲区，用于存放接收到的数据，发送的数据将其转换后也放入该缓冲区中，代码晦涩难懂，我也是经过打日志分析后，才明白点，这个缓冲区自己还得控制好。但是libevent 2已经提供了一个神器bufferevent，我们在使用的过程中最好不要自己管理这个缓冲区，之所以分析这个代码，是为了熟悉libevent 做服务端程序的流程及原理。

下面是代码，加有部分注释和日志：

代码：lowlevel_libevent_server.c 

 //说明，为了使我们的代码兼容win32网络API，我们使用evutil_socket_t代替int，使用evutil_make_socket_nonblocking代替fcntl

 /* For sockaddr_in */
 #include <netinet/in.h>
 /* For socket functions */
 #include <sys/socket.h>
 /* For fcntl */
 #include <fcntl.h>

 #include <event2/event.h>

 #include <assert.h>
 #include <unistd.h>
 #include <string.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <errno.h>

 #define MAX_LINE 80

 void do_read(evutil_socket_t fd, short events, void *arg);
 void do_write(evutil_socket_t fd, short events, void *arg);

 char rot13_char(char c)
 {
     /* We don't want to use isalpha here; setting the locale would change
      * which characters are considered alphabetical. */
     if ((c >= 'a' && c <= 'm') || (c >= 'A' && c <= 'M'))
         return c + 13;
     else if ((c >= 'n' && c <= 'z') || (c >= 'N' && c <= 'Z'))
         return c - 13;
     else
         return c;
 }

 struct fd_state {
     char buffer[MAX_LINE];
     size_t buffer_used;

     size_t n_written;
     size_t write_upto;

     struct event *read_event;
     struct event *write_event;
 };

 struct fd_state * alloc_fd_state(struct event_base *base, evutil_socket_t fd)
 {
     struct fd_state *state = malloc(sizeof(struct fd_state));
     if (!state)
         return NULL;

     state->read_event = event_new(base, fd, EV_READ|EV_PERSIST, do_read, state);
     if (!state->read_event)
     {
         free(state);
         return NULL;
     }

     state->write_event = event_new(base, fd, EV_WRITE|EV_PERSIST, do_write, state);
     if (!state->write_event)
     {
         event_free(state->read_event);
         free(state);
         return NULL;
     }

     state->buffer_used = state->n_written = state->write_upto = 0;

     assert(state->write_event);
     return state;
 }

 void free_fd_state(struct fd_state *state)
 {
     event_free(state->read_event);
     event_free(state->write_event);
     free(state);
 }

 void do_read(evutil_socket_t fd, short events, void *arg)
 {
     struct fd_state *state = arg;
     char buf[20];
     int i;
     ssize_t result;
     printf("\ncome in do_read: fd: %d, state->buffer_used: %d, sizeof(state->buffer): %d\n", fd, state->buffer_used, size
 of(state->buffer));
     while (1)
     {
         assert(state->write_event);
         result = recv(fd, buf, sizeof(buf), 0);
         if (result <= 0)
             break;
         printf("recv once, fd: %d, recv size: %d, recv buff: %s\n", fd, result, buf);

         for (i=0; i < result; ++i)
         {
             if (state->buffer_used < sizeof(state->buffer))//如果读事件的缓冲区还未满，将收到的数据做转换
                 state->buffer[state->buffer_used++] = rot13_char(buf[i]);
 //              state->buffer[state->buffer_used++] = buf[i];//接收什么发送什么，不经过转换，测试用
             if (buf[i] == '\n') //如果遇到换行，添加写事件，并设置写事件的大小
             {
                 assert(state->write_event);
                 event_add(state->write_event, NULL);
                 state->write_upto = state->buffer_used;
                 printf("遇到换行符，state->write_upto: %d, state->buffer_used: %d\n",state->write_upto, state->buffer_use
 d);
             }
         }
         printf("recv once, state->buffer_used: %d\n", state->buffer_used);
 }

     //判断最后一次接收的字节数
     if (result == 0)
     {
         free_fd_state(state);
     }
     else if (result < 0)
     {
         if (errno == EAGAIN) // XXXX use evutil macro
             return;
         perror("recv");
         free_fd_state(state);
     }
 }

 void do_write(evutil_socket_t fd, short events, void *arg)
 {
     struct fd_state *state = arg;

     printf("\ncome in do_write, fd: %d, state->n_written: %d, state->write_upto: %d\n",fd, state->n_written, state->write
 _upto);
     while (state->n_written < state->write_upto)
     {
         ssize_t result = send(fd, state->buffer + state->n_written, state->write_upto - state->n_written, 0);
         if (result < 0) {
             if (errno == EAGAIN) // XXX use evutil macro
                 return;
             free_fd_state(state);
             return;
         }
         assert(result != 0);

         state->n_written += result;
         printf("send fd: %d, send size: %d, state->n_written: %d\n", fd, result, state->n_written);
     }

     if (state->n_written == state->buffer_used)
     {
         printf("state->n_written == state->buffer_used: %d\n", state->n_written);
         state->n_written = state->write_upto = state->buffer_used = 1;
         printf("state->n_written = state->write_upto = state->buffer_used = 1\n");
     }

     event_del(state->write_event);
 }

 void do_accept(evutil_socket_t listener, short event, void *arg)
 {
     struct event_base *base = arg;
     struct sockaddr_storage ss;
     socklen_t slen = sizeof(ss);
     int fd = accept(listener, (struct sockaddr*)&ss, &slen);
     if (fd < 0)
     { // XXXX eagain??
         perror("accept");
     }
     else if (fd > FD_SETSIZE)
     {
         close(fd); // XXX replace all closes with EVUTIL_CLOSESOCKET */
     }
     else
     {
         struct fd_state *state;
         evutil_make_socket_nonblocking(fd);
         state = alloc_fd_state(base, fd);
         assert(state); /*XXX err*/
         assert(state->write_event);
         event_add(state->read_event, NULL);
     }
 }

 void run(void)
 {
     evutil_socket_t listener;
     struct sockaddr_in sin;
     struct event_base *base;
     struct event *listener_event;

     base = event_base_new();//初始化libevent
     if (!base)
         return; /*XXXerr*/

     sin.sin_family = AF_INET;
     sin.sin_addr.s_addr = 0;//本机
     sin.sin_port = htons(8000);

     listener = socket(AF_INET, SOCK_STREAM, 0);
     evutil_make_socket_nonblocking(listener);

 #ifndef WIN32
     {
         int one = 1;
         setsockopt(listener, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one));
     }
 #endif

     if (bind(listener, (struct sockaddr*)&sin, sizeof(sin)) < 0)
     {
         perror("bind");
         return;
 　　}


 　　    if (listen(listener, 16)<0)
 　　    {
 　　        perror("listen");
 　　        return;
 　　    }

 　　    listener_event = event_new(base, listener, EV_READ|EV_PERSIST, do_accept, (void*)base);
 　　    /*XXX check it */
 　　    event_add(listener_event, NULL);

 　　    event_base_dispatch(base);
 　　}

 　　int main(int c, char **v)
 　　{
 　　//    setvbuf(stdout, NULL, _IONBF, 0);

 　　    run();
 　　    return 0;
 　　}

编译：gcc -I/usr/include -o test lowlevel_libevent_server.c -L/usr/local/lib -levent

运行结果：

处理大并发之五 使用libevent利器bufferevent

分类： linux 网络编程 2013-07-19 23:21  1742人阅读  评论(0)  收藏  举报

大并发处理 libevent源码研究 bufferevent

处理大并发之五 使用libevent利器bufferevent

         首先来翻译一段文章

         你可能注意到随着我们代码变得越来越高效，程序也变得更加复杂。当我们产生一个进程的时候，我们没有必要为每一个链接管理一个buffer，我们只需要每个处理独立栈分配缓冲区就可以了。在读和写的时候，我们不必明确的跟踪每一个socket，这在我们的代码里是一个暗示，我们没有必要定义一个结构体去跟踪每一个操作什么时候完成，我们只需要使用循环栈变量就可以了。

         此外，如果你在windows网络编程方面有着丰富的经验，当你在使用上一篇博客中的例子时，你可能认识到libevent可能达不到最理想的性能。在windows上，你做的快速异步IO不是用的select，它使用的IOCP API。和其他的快速网络API不同，当你的程序执行完成，sock准备完成，IOCP不会通知你的程序，取而代之的是，程序告诉windows网络栈开启一个网络操作，并且当操作执行完成时，IOCP会告诉程序。

         幸运的是，libevent2 的bufferevents接口解决了上面的这些冲突，它使得程序更加容易写，并且为windows和unix提供了有效的接口。

分析：

libevent的bufferevent在event的基础上自己维护了一个buffer，这样的话，就不需要再自己管理一个buffer了，上一篇博客是自己维护一个buffer，维护过程复杂，且过程难以理解，既然libevent自己提供了bufferevent这个神器，且有API，何必自己维护呢？

先看看struct bufferevent这个结构体

 struct bufferevent {
                struct event_base *ev_base;
         const struct bufferevent_ops *be_ops;
         struct event ev_read;
         struct event ev_write;
         struct evbuffer *input;
         struct evbuffer *output;
         ……
         bufferevent_data_cb readcb;
         bufferevent_data_cb writecb;
         bufferevent_event_cb errorcb;
         ……
 }

可以看出struct bufferevent内置了两个event（读/写）和对应的缓冲区。当有数据被读入(input)的时候，readcb被调用，当output被输出完成的时候，writecb被调用，当网络I/O出现错误，如链接中断，超时或其他错误时，errorcb被调用。

使用bufferevent的过程：

1. 设置sock为非阻塞的

 eg:  evutil_make_socket_nonblocking(fd);

2. 使用bufferevent_socket_new创建一个structbufferevent *bev，关联该sockfd，托管给event_base

函数原型为：

 struct bufferevent * bufferevent_socket_new(struct event_base *base, evutil_socket_t fd,  int options)
 eg:  struct bufferevent *bev;
 bev = bufferevent_socket_new(base, fd, BEV_OPT_CLOSE_ON_FREE);

3. 设置读写对应的回调函数

函数原型为：

 void bufferevent_setcb(struct bufferevent *bufev,
     bufferevent_data_cb readcb, bufferevent_data_cb writecb,
     bufferevent_event_cb eventcb, void *cbarg)
 eg.  bufferevent_setcb(bev, readcb, NULL, errorcb, NULL);

4. 启用读写事件,其实是调用了event_add将相应读写事件加入事件监听队列poll。正如文档所说，如果相应事件不置为true，bufferevent是不会读写数据的

函数原型：

 int bufferevent_enable(struct bufferevent *bufev, short event)
 eg.  bufferevent_enable(bev, EV_READ|EV_WRITE);

5. 进入bufferevent_setcb回调函数：

在readcb里面从input中读取数据，处理完毕后填充到output中；

writecb对于服务端程序，只需要readcb就可以了，可以置为NULL；

errorcb用于处理一些错误信息。

针对这些使用过程进入源码进行分析：

1. bufferevent_socket_new

（1）在bufferevent_init_common中调用evbuffer_new()初始化input和output

（2）在event_assign中初始化bufferevent中的ev_read和ev_write事件。

（3）在evbuffer_add_cb中给output添加了一个callback bufferevent_socket_outbuf_cb

2. bufferevent_setcb

该函数的作用主要是赋值，把该函数后面的参数，赋值给第一个参数struct bufferevent *bufev定义的变量

3. bufferevent_enable

调用event_add将读写事件加入到事件监听队列中。

 

对bufferevent常用的几个函数进行分析：

 char *evbuffer_readln(struct evbuffer*buffer, size_t *n_read_out,enum evbuffer_eol_style eol_style);

含义：Read a single line from an evbuffer.

返回值：读到的一行内容

 int evbuffer_add(struct evbuffer *buf,const void *data, size_t datlen);

含义：将数据添加到evbuffer的结尾

返回值：成功返回0，失败返回-1

 int evbuffer_remove(struct evbuffer*buf, void *data, size_t datlen);

含义：从evbuffer读取数据到data

返回值：成功返回0，失败返回-1

 size_t evbuffer_get_length(const structevbuffer *buf);

含义：返回evbuffer中存储的字节长度

暂时先分析到这里，下面是代码，客户端发送消息：HTTP/1.0, Client 0 send Message:

Request: Hello Server! over，服务端一条消息收完成后，会回复：Response ok! Hello Client!

服务端从bufferevent中取出消息是按行取的。代码可能有不完善的地方，由于才疏学浅，研究时间短（3天），希望高手提出宝贵意见。

libevent_eventbuffer_server.c

 #include <netinet/in.h>
 #include <sys/socket.h>
 #include <fcntl.h>

 #include <event2/event.h>
 #include <event2/buffer.h>
 #include <event2/bufferevent.h>

 #include <assert.h>
 #include <unistd.h>
 #include <string.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <errno.h>

 void do_read(evutil_socket_t fd, short events, void *arg);

 //struct bufferevent内建了两个event(read/write)和对应的缓冲区(struct evbuffer *input, *output)，并提供相应的函数用来操作>
 缓冲区(或者直接操作bufferevent)
 //接收到数据后，判断是不一样一条消息的结束，结束标志为"over"字符串
 void readcb(struct bufferevent *bev, void *ctx)
 {
     printf("called readcb!\n");
     struct evbuffer *input, *output;
     char *request_line;
     size_t len;
     input = bufferevent_get_input(bev);//其实就是取出bufferevent中的input
     output = bufferevent_get_output(bev);//其实就是取出bufferevent中的output

     size_t input_len = evbuffer_get_length(input);
     printf("input_len: %d\n", input_len);
     size_t output_len = evbuffer_get_length(output);
     printf("output_len: %d\n", output_len);

     while(1)
     {
         request_line = evbuffer_readln(input, &len, EVBUFFER_EOL_CRLF);//从evbuffer前面取出一行，用一个新分配的空字符结束
 的字符串返回这一行,EVBUFFER_EOL_CRLF表示行尾是一个可选的回车，后随一个换行符
         if(NULL == request_line)
         {
             printf("The first line has not arrived yet.\n");
             free(request_line);//之所以要进行free是因为 line = mm_malloc(n_to_copy+1))，在这里进行了malloc
             break;
         }
         else
 <span style="white-space: pre;">    </span>{
             printf("Get one line date: %s\n", request_line);
             if(strstr(request_line, "over") != NULL)//用于判断是不是一条消息的结束
             {
                 char *response = "Response ok! Hello Client!\r\n";
                 evbuffer_add(output, response, strlen(response));//Adds data to an event buffer
                 printf("服务端接收一条数据完成，回复客户端一条消息: %s\n", response);
                 free(request_line);
                 break;
             }
         }
         free(request_line);
     }

     size_t input_len1 = evbuffer_get_length(input);
     printf("input_len1: %d\n", input_len1);
     size_t output_len1 = evbuffer_get_length(output);
     printf("output_len1: %d\n\n", output_len1);
 }

 void errorcb(struct bufferevent *bev, short error, void *ctx)
 {
     if (error & BEV_EVENT_EOF)
     {
         /* connection has been closed, do any clean up here */
         printf("connection closed\n");
     }
     else if (error & BEV_EVENT_ERROR)
     {
         /* check errno to see what error occurred */
         printf("some other error\n");
     }
     else if (error & BEV_EVENT_TIMEOUT)
     {
         /* must be a timeout event handle, handle it */
         printf("Timed out\n");
     }
     bufferevent_free(bev);
 }

 void do_accept(evutil_socket_t listener, short event, void *arg)
 {
     struct event_base *base = arg;
     struct sockaddr_storage ss;
     socklen_t slen = sizeof(ss);
     int fd = accept(listener, (struct sockaddr*)&ss, &slen);
     if (fd < 0)
     {
         perror("accept");
     }
     else if (fd > FD_SETSIZE)
     {
         close(fd);
     }
     else
     {
         struct bufferevent *bev;
         evutil_make_socket_nonblocking(fd);

         //使用bufferevent_socket_new创建一个struct bufferevent *bev，关联该sockfd，托管给event_base
         ////BEV_OPT_CLOSE_ON_FREE表示释放bufferevent时关闭底层传输端口。这将关闭底层套接字，释放底层bufferevent等。
         bev = bufferevent_socket_new(base, fd, BEV_OPT_CLOSE_ON_FREE);

         //设置读写对应的回调函数
         bufferevent_setcb(bev, readcb, NULL, errorcb, NULL);
 //      bufferevent_setwatermark(bev, EV_READ, 0, MAX_LINE);

         //启用读写事件,其实是调用了event_add将相应读写事件加入事件监听队列poll。正如文档所说，如果相应事件不置为true，buf
 ferevent是不会读写数据的
         bufferevent_enable(bev, EV_READ|EV_WRITE);
     }
 }

 void run(void)
 {
     evutil_socket_t listener;
     struct sockaddr_in sin;
     struct event_base *base;
     struct event *listener_event;

     base = event_base_new();
     if (!base)
         return; /*XXXerr*/

     sin.sin_family = AF_INET;
     sin.sin_addr.s_addr = 0;
     sin.sin_port = htons(8000);

     listener = socket(AF_INET, SOCK_STREAM, 0);
     evutil_make_socket_nonblocking(listener);

 #ifndef WIN32
     {
         int one = 1;
         setsockopt(listener, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one));
     }
 #endif

     if (bind(listener, (struct sockaddr*)&sin, sizeof(sin)) < 0)
     {
         perror("bind");
         return;
     }
 if (listen(listener, 16)<0)
     {
         perror("listen");
         return;
     }

     listener_event = event_new(base, listener, EV_READ|EV_PERSIST, do_accept, (void*)base);
     /*XXX check it */
     event_add(listener_event, NULL);

     event_base_dispatch(base);
 }

 int main(int argc, char **argv)
 {
     setvbuf(stdout, NULL, _IONBF, 0);

     run();
     return 0;
 }

编译：gcc -I/usr/include-o test libevent_eventbuffer_server.c -L/usr/local/lib –levent

运行：

服务端：

客户端：

今晚博客暂时写完了，时间比较仓促，错误估计不会少，关于bufferevent很多API都还不是很熟悉，还有libevent 添加事件event_add是非线程安全的，如果使用多线程，需要保证event_add不能出现在多个线程中，以后有时间慢慢研究。

体会：关于源码，还需要好好研究，其实今晚挺郁闷的，弄了半天，没有什么进展，现在自己还有很多疑问，主要是自己太急了，不过3天时间做到基本了解，自己还算满意，下一步有时间多研究下吧。晚安，北京

如是转载，请指明原出处： http://blog.csdn.net/feitianxuxue，谢谢合作！