Libevent：5events相关

         Libevents的基本操作单元是event，每一个event代表了一些条件的集合，这些条件包括：

文件描述符已经准备好读或写

文件描述符正在变为就绪，准备好读或写（仅限于边沿触发）

超时事件

信号发生

用户触发事件

 

         events都有类似的生命周期。一旦调用Libevent函数创建好event，并将其关联到一个event_base之后，他就是“已初始化”状态（initialized）。这种状态下，可以进行add操作，将其状态变为base中的“挂起”状态（pending），处于“挂起”状态的event，如果触发事件的条件发生了（比如，文件描述符的状态发生变化，或者超时了），那么event的状态变为“激活”状态（active），然后它的回调函数（用户提供）开始运行。如果该event配置了“持久”属性（persistent），那么它的状态依然保持为“挂起”，否则，在回调函数运行时，它的状态就不再是“挂起”（“非挂起”状态）。可以通过delete操作，将一个“挂起”状态的event变为“非挂起”状态（non-pending），或者通过add操作，将“非挂起”的event变为“挂起”状态。

 

一：构建event对象

         创建新的event，可以使用event_new接口：

#define EV_TIMEOUT      0x01

#define EV_READ         0x02

#define EV_WRITE        0x04

#define EV_SIGNAL       0x08

#define  EV_PERSIST      0x10

#define EV_ET           0x20

 

typedef void  (*event_callback_fn)(evutil_socket_t,  short,  void*);

 

struct event * event_new(struct  event_base *base,  evutil_socket_t  fd,

                                                    shortwhat,  event_callback_fn  cb,

                                                    void* arg);

 

void  event_free(struct  event * event);

         event_new函数分配并且创建一个新的event对象，并与base进行关联。what参数是上面列出标志的集合，它们的具体意义见下方。如果fd是非负的整数，则它代表了我们需要观察可读或可写事件的文件。当event变为激活时，Libevent就会调用回调函数cb，将文件描述符参数fd，所有触发事件的标志位域，以及event_new的最后一个参数：arg传递个cb。

         如果发生了内部错误，或者参数非法，则event_new返回NULL。

         所有新的events都是“已初始化”和“非挂起”状态，可以调用event_add函数将这样的event变为“挂起”状态。

         调用event_free可以销毁event。对“挂起”或“激活”状态的event调用event_free也是安全的：在销毁它之前，会将其变为“非挂起”以及“非激活”状态。

#include <event2/event.h>

 

void  cb_func(evutil_socket_t  fd,  short what,  void * arg)

{

        const char *data = arg;

        printf("Got an event on socket %d:%s%s%s%s [%s]",

            (int) fd,

            (what&EV_TIMEOUT) ? " timeout" : "",

            (what&EV_READ)    ? " read" : "",

            (what&EV_WRITE)   ? " write" : "",

            (what&EV_SIGNAL)  ? " signal" : "",

            data);

}

 

void  main_loop(evutil_socket_t  fd1,  evutil_socket_t fd2)

{

        struct  event *ev1, *ev2;

        struct  timeval  five_seconds = {5,0};

        struct  event_base * base = event_base_new();

 

        /* The caller has already set up fd1,fd2 somehow, and make them

           nonblocking. */

 

        ev1 = event_new(base,  fd1,  EV_TIMEOUT|EV_READ|EV_PERSIST,  cb_func,

           (char*)"Reading event");

        ev2 = event_new(base,  fd2,  EV_WRITE|EV_PERSIST,  cb_func,

           (char*)"Writing event");

 

        event_add(ev1,  &five_seconds);

        event_add(ev2,  NULL);

        event_base_dispatch(base);

}

         上述函数在<event2/event.h>文件中定义。

 

event标志：

EV_TIMEOUT：

         该标志表明，超时时间过后，该event变为“激活”状态。（注意：在构建event时，EV_TIMEOUT标志是被忽略的：当add event时可以设置超时时间，也可以不设置。当超时发生时，回调函数的what参数将会设置该标志。）

EV_READ

         该标志表明，当文件描述符准备好读时，event将会变为“激活”

EV_WRITE

         该标志表明，当文件描述符准备好写时，event将会变为“激活”

EV_SIGNAL

         用来实现信号探测，参见下面的“构造信号事件”

EV_PERSIST：

         标志该event具有“持久”属性，参见下面的“事件持久性”

EV_ET:

         指明如果event_base的底层方法支持“边沿触发”的话，那么该event应该是边沿触发的。这将会影响到EV_READ和EV_WRITE       

        

         自Libevent2.0.1-alpha版本以来，同一时刻，针对同一个文件描述符，可以有任意数量的event在同样的条件上“挂起”。比如，当给定的fd变为可读时，可以使两个events都变为激活状态。但是他们的回调函数的调用顺序是未定义的。

 

         所有这些标志都在<event2/event.h>中定义。

 

二：事件持久性

         默认情况下，当一个“挂起”的event变为“激活”时（要么是因为fd准备好读或写，要么是超时时间到），那么在它的回调函数执行之前，它就会变为“非挂起”状态。因此，如果希望再次使event变为“挂起”状态，可以在回调函数内部再次调用event_add函数。

         如果event设置了EV_PERSIST标志，那么event就是“持久”的。这意味着event在回调函数激活的时候，依然保持“挂起”状态。如果希望在回调函数中将event变为“非挂起”状态，则可以调用event_del函数。

 

         当event的回调函数运行时，“持久”event的超时时间就会被重置。因此，如果某个event标志为EV_READ|EV_PERSIST，并且将超时时间设置为5秒，则该event在下面的条件发生时，会变为“激活”：

当该socket准备好读时；

距离上次event变为激活状态后，又过了5秒钟。

 

三：创建一个可以将自身作为回调函数参数的的event

         经常可能会希望创建这样一个event，它本身就是是回调函数的参数之一。不能仅仅传递一个指向event的指针作为event_new的参数，因为彼时它还没有创建。此时，可以通过调用event_self_cbarg函数解决这样的问题。

void*event_self_cbarg();

         该函数返回一个“魔术”指针，使得event_new创建一个本身就能作为回调函数参数的event。

#include <event2/event.h>

 

static int  n_calls = 0;

 

void  cb_func(evutil_socket_t  fd,  short what,  void * arg)

{

    struct  event *me = arg;

 

    printf("cb_func  called  %d times  so far.\n",  ++n_calls);

 

    if (n_calls > 100)

       event_del(me);

}

 

void  run(struct  event_base * base)

{

    struct  timeval  one_sec = { 1, 0 };

    struct  event *ev;

    /* We're going to set up a repeating timerto get called 100 times. */

   ev = event_new(base,  -1,  EV_PERSIST, cb_func,  event_self_cbarg());

    event_add(ev,  &one_sec);

    event_base_dispatch(base);

}

         该函数还可以与函数event_new,evtimer_new, evsignal_new, event_assign, evtimer_assign和evsignal_assign一起使用。然而对于非event来说，他不会作为回调函数的参数。

 

四：纯超时events

         方便起见，Libevent提供了一系列以evtimer_开头的宏，这些宏可以代替event_*函数，来分配和操作纯超时events。使用这些宏仅能提高代码的清晰度而已。

#define evtimer_new(base,  callback,  arg)   event_new((base), -1, 0, (callback), (arg))

#define evtimer_add(ev,  tv)                              event_add((ev),(tv))

#define evtimer_del(ev)                                                            event_del(ev)

#define evtimer_pending(ev,  tv_out)   event_pending((ev), EV_TIMEOUT, (tv_out))

 

 

五：构造信号事件

         Libevent也可以监控POSIX类的信号。构建一个信号处理函数，可以使用下面的接口：

#define evsignal_new(base,  signum,  cb,  arg)\

    event_new(base,  signum,  EV_SIGNAL|EV_PERSIST,  cb,  arg)

         除了提供一个代表信号值的整数，而不是一个文件描述符之外。它的参数与event_new是一样的。

struct event * hup_event;

struct event_base  *base = event_base_new();

 

/*call sighup_function on a HUP signal */

hup_event= evsignal_new(base,  SIGHUP,  sighup_function,  NULL);

         注意：信号回调函数是在信号发生之后，在eventloop中调用的。所以，它们可以调用那些，对于普通POSIX信号处理函数来说不是信号安全的函数。

         注意：不要在一个信号event上设置超时，不支持这样做。

 

         对于信号event，同样有一些方便的宏可以使用：

#define evsignal_add(ev,  tv)                             event_add((ev), (tv))

#define evsignal_del(ev)                                        event_del(ev)

#define evsignal_pending(ev,  what,  tv_out)  event_pending((ev), (what), (tv_out))

         警告：当前版本的Libevent，对于大多数的后端方法来说，同一时间，每个进程仅能有一个event_base可以用来监听信号。如果一次向两个event_base添加event，即使是不同的信号，也仅仅会只有一个event_base可以接收到信号。对于kqueue来说，不存在这样的限制。

 

 

六：不在堆中分配event

         出于性能或者其他原因的考虑，一些人喜欢将event作为一个大的结构体的一部分进行分配。对于这样的event，它节省了：

内存分配器在堆上分配小对象的开销；

event指针的解引用的时间开销；

如果event没有在缓存中，缓存不命中的时间开销。

 

         这种方法的风险在于，与其他版本的Libevent之间不满足二进制兼容性，他们可能具有不同的event大小。

 

         这些开销都非常小，对于大多数应用来说是无关紧要的。除非确定知道，应用程序因为使用堆分配的event而存在严重的性能损失，否则应该坚持实用event_new。如果后续版本的Libevent使用比当前Libevent更大的event结构，那么使用event_assign有可能会导致难以诊断的错误。

int  event_assign(struct  event * event, struct  event_base * base,

                                 evutil_socket_t fd,  short  what,

                                 void(*callback)(evutil_socket_t,  short,  void *),  void * arg);

         event_assign的参数与event_new相同，除了event参数，该参数指针必须指向一个未初始化的event。该函数成功时返回0，失败时返回-1.

#include <event2/event.h>

/*Watch out! Including event_struct.h means that your code willnot

 * be binary-compatible with future versions ofLibevent. */

#include <event2/event_struct.h>

#include <stdlib.h>

 

struct event_pair {

         evutil_socket_t  fd;

         struct event  read_event;

         struct event  write_event;

};

void  readcb(evutil_socket_t,  short,  void*);

void  writecb(evutil_socket_t,  short,  void*);

struct event_pair * event_pair_new(struct  event_base * base,  evutil_socket_t  fd)

{

        struct  event_pair  *p = malloc(sizeof(struct  event_pair));

        if (!p) return NULL;

        p->fd = fd;

        event_assign(&p->read_event,  base,  fd, EV_READ|EV_PERSIST,  readcb,  p);

        event_assign(&p->write_event,  base,  fd,  EV_WRITE|EV_PERSIST,writecb, p);

        return  p;

}

         同样可以使用event_assign来初始化栈或者静态存储区中的events。

 

警告：

         对于已经在event_base中处于“挂起”状态的event，永远不要调用event_assign。这样做会导致极为难以诊断的错误。如果event已经初始化，并且处于“挂起”状态，那么在调用event_assign之前应该先调用event_del。

 

         对于使用event_assign分配的纯超时event或者信号event，同样有方便的宏可以使用：

#define evtimer_assign(event,  base,  callback, arg) \

              event_assign(event, base,  -1,  0,  callback,  arg)

#define evsignal_assign(event,  base,  signum, callback,  arg) \

              event_assign(event, base,  signum,  EV_SIGNAL|EV_PERSIST,  callback,  arg)

        

         如果需要在与未来版本的LIbevent保持二进制兼容性的同时，使用event_assign，可以调用Libevent中的函数，得到运行时的event结构大小：

size_t event_get_struct_event_size(void);

         该函数返回需要为event结构预留的字节数。再次提醒，只有在确定堆分配导致很明显的性能问题时，才应该使用该函数，因为它使你的代码难读又难写。

         注意，将来版本的event_get_struct_event_size()的返回值可能比sizeof(structevent)小，这意味着event结构的末尾的额外字节仅仅是保留用于未来版本的Libevent的填充字节。

         下面是一个使用event_get_struct_size的例子：

#include <event2/event.h>

#include <stdlib.h>

 

/*When we allocate an event_pair in memory, we'll actually allocate

 * more space at the end of the structure.  We define some macros

 * to make accessing those events lesserror-prone. */

struct event_pair {

         evutil_socket_t  fd;

};

 

/*Macro: yield the struct event 'offset' bytes from the start of 'p' */

#define EVENT_AT_OFFSET(p,  offset) \

            ((struct  event*) ( ((char*)(p)) + (offset) ))

/*Macro: yield the read event of an event_pair */

#define READEV_PTR(pair) \

            EVENT_AT_OFFSET((pair),  sizeof(struct event_pair))

/*Macro: yield the write event of an event_pair */

#define WRITEEV_PTR(pair) \

            EVENT_AT_OFFSET((pair), \

                sizeof(struct  event_pair)+event_get_struct_event_size())

 

/*Macro: yield the actual size to allocate for an event_pair */

#defineEVENT_PAIR_SIZE() \

            (sizeof(struct  event_pair)+2*event_get_struct_event_size())

 

voidreadcb(evutil_socket_t, short, void *);

voidwritecb(evutil_socket_t, short, void *);

struct event_pair *event_pair_new(struct  event_base *base, evutil_socket_t  fd)

{

        struct  event_pair *p = malloc(EVENT_PAIR_SIZE());

        if (!p) return NULL;

        p->fd = fd;

       event_assign(READEV_PTR(p), base, fd,EV_READ|EV_PERSIST, readcb, p);

        event_assign(WRITEEV_PTR(p), base, fd,EV_WRITE|EV_PERSIST, writecb, p);

        return p;

}

         event_assign函数定义在文件<event2/event.h>中。event结构体定义在<event2/event_struct.h>文件中。

 

七：将events置为“挂起”或者“非挂起”

         刚创建的一个event，实际上不能做任何事，直到通过调用event_add进行adding操作，将其置为“挂起”状态。

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

         在“非挂起”状态的events上执行event_add操作，则会使得该event在配置的event_base上变为“挂起”状态。该函数返回0表示成功，返回-1表示失败。如果tv为NULL，则该event没有超时时间。否则，tv以秒和毫妙表示超时时间。

         如果在已经是“挂起”状态的event进行event_add操作，则会保持其“挂起”状态，并且会重置其超时时间。如果event已经是“挂起”状态，而且以NULL为超时时间对其进行re-add操作，则event_add没有任何作用。

         注意：不要设置tv为希望超时事件执行的时间，比如如果置tv->tv_sec=time(NULL)+10，并且当前时间为2010/01/01，则超时时间为40年之后，而不是10秒之后。

 

int  event_del(struct event *ev);

         在已经初始化状态的event上调用event_del，则会将其状态变为“非挂起”以及“非激活”状态。如果event的当前状态不是“挂起”或“激活”状态，则该函数没有任何作用。该函数返回0表示成功，返回-1表示失败。

         注意，如果在event刚变为“激活”状态，但是它的回调函数还没有执行时，调用event_del函数，则该操作使得它的回调函数不会执行。

 

int  event_remove_timer(struct  event *ev);

         最后，可以在不删除event上的IO事件或信号事件的情况下，删除一个“挂起”状态的event上的超时事件。如果该event没有超时事件，则event_remove_timer没有作用。如果event没有IO事件或信号事件，只有超时事件的话，则event_remove_timer等同于event_del。该函数返回0表示成功，-1表示失败。

         这些函数都是在文件<event2/event.h>中定义的。

 

八：事件的优先级

         当多个事件在同一时间触发时，Libevent对于他们回调函数的调用顺序是没有定义的。可以通过优先级，定义某些“更重要”的events。

         每一个event_base都有一个或多个优先级的值。在event初始化之后，添加到event_base之前，可以设置该event的优先级。

int  event_priority_set(struct  event *event,  int  priority);

         event的优先级数必须是位于0到“event_base优先级”-1这个区间内。该函数返回0表示成功，返回-1表示失败。

         当具有多种优先级的多个events同时激活的时候，低优先级的events不会运行。Libevent会只运行高优先级的events，然后重新检查events。只有当没有高优先级的events激活时，才会运行低优先级的events。

#include <event2/event.h>

 

void  read_cb(evutil_socket_t,  short,  void*);

void  write_cb(evutil_socket_t,  short,  void*);

 

voidmain_loop(evutil_socket_t  fd)

{

  struct  event  *important,  *unimportant;

  struct  event_base  *base;

 

  base = event_base_new();

 event_base_priority_init(base, 2);

  /* Now base has priority 0, and priority 1 */

  important = event_new(base,  fd,  EV_WRITE|EV_PERSIST,  write_cb,  NULL);

  unimportant = event_new(base,  fd,  EV_READ|EV_PERSIST, read_cb,  NULL);

  event_priority_set(important, 0);

  event_priority_set(unimportant, 1);

 

  /*Now, whenever the fd is ready for writing, the write callback will

     happen before the read callback.  The read callback won't happen at

     all until the write callback is no longeractive.*/

}

         如果没有设置一个event的优先级，则它的默认优先级是“event_base队列长度”除以2。该函数在文件<event2/event.h>中声明。

 

九：检查event状态

         有时可能希望知道event是否已经添加了（处于“挂起”状态），或者检查他关联到哪个event_base等。

int  event_pending(const struct  event *ev,  short  what,  struct timeval  *tv_out);

 

#define event_get_signal(ev) /* ... */

evutil_socket_t event_get_fd(const  struct  event *ev);

struct event_base *event_get_base(const  struct event  *ev);

short event_get_events(const  struct  event  *ev);

event_callback_fn event_get_callback(const  struct event *ev);

void*event_get_callback_arg(const  struct  event  *ev);

int  event_get_priority(const struct  event *ev);

 

void  event_get_assignment(const struct event*event,

        struct  event_base  **base_out,

        evutil_socket_t  *fd_out,

        short  *events_out,

        event_callback_fn  *callback_out,

        void  **arg_out);

 

         event_pending函数检查给定的event是否处于“挂起”或“激活”状态。如果确实如此，并且在what参数中设置了任何EV_READ, EV_WRITE, EV_SIGNAL或EV_TIMEOUT标志的话，则该函数返回所有该event当前正在“挂起”或“激活”的标志。

         如果提供了tv_out参数，且在what参数中设置了EV_TIMEOUT参数，并且当前event确实在超时事件上“挂起”或者“激活”，则tv_out就会设置为event的超时时间。

 

         event_get_fd和event_get_signal函数返回event上配置的文件描述符或者信号值。event_get_base()返回其配置的event_base。event_get_events() 返回event上配置的事件标志（EV_READ,EV_WRITE等）。event_get_callback函数和event_get_callback_arg函数返回event的回调函数和参数指针。event_get_priority函数返回event的当前优先级。

 

         event_get_assignment函数在提供的参数指针中返回event的所有成分，如果参数指针为NULL，则该成分被忽略。

#include <event2/event.h>

#include <stdio.h>

 

/*Change the callback and callback_arg of 'ev', which must not be pending. */

int  replace_callback(struct  event *ev,  event_callback_fn  new_callback,

     void* new_callback_arg)

{

    struct  event_base  *base;

    evutil_socket_t  fd;

    short  events;

 

    int  pending;

    pending = event_pending(ev, EV_READ|EV_WRITE|EV_SIGNAL|EV_TIMEOUT, NULL);

    if (pending) {

        /*We want to catch this here so that we do notre-assign a

         * pending event.  That would be very very bad.*/

       fprintf(stderr, "Error! replace_callbackcalled on a pending event!\n");

        return -1;

    }

 

    event_get_assignment(ev,  &base, &fd,  &events,

                         NULL /* ignore oldcallback */ ,

                         NULL /* ignore oldcallback argument */);

 

   event_assign(ev,  base,  fd,  events,new_callback,  new_callback_arg);

    return 0;

}

         这些函数在文件<event2/event.h>中定义。

 

十：找到当前正在运行的event

         在调试程序时，可以得到当前正在运行的event的指针。

struct event * event_base_get_running_event(struct event_base * base);

         注意，只有在base的loop中调用该函数，该函数才有意义。在其他线程调用时不支持的，而且会导致未定义的行为。

         该函数在<event2/event.h>中声明。

 

十一：配置一次性的events    

         如果不需要对一个event进行多次添加，或者对一个非持久的event，在add之后就会delete，则可以使用event_base_once函数。

int event_base_once(struct event_base *,  evutil_socket_t,  short,

                   void (*) (evutil_socket_t,  short,  void*),  void *,  const struct timeval *);

         该函数的参数与event_new一样，不同的是它不支持EV_SIGNAL或EV_PERSIST标志。得到的内部event会以默认的优先级添加到event_base中并运行。当它的回调函数执行完成之后，Libevent将会释放该内部event。该函数成功时返回0，失败是返回-1.

 

         通过event_base_once插入的event不能被删除或者手动激活。如果希望可以取消一个event，则需要通过常规的event_new或event_assign接口创建event。

        

         注意，直到Libevent2.0之前，如果event一直没有触发，则它的内存永远不会被释放。从Libevent2.1.2-alpha版本开始，当event_base释放时，即使events还没有被激活，它们的内存也会被释放。但是依然要注意：如果它们的回调函数的参数具有关联的内存，那么除非程序中进行释放，否则这些内存永远不会被释放。

 

十二：手动激活event

         某些极少的情况下，你可能希望在条件未被触发的情况下就激活event；

void  event_active(struct  event *ev, int  what, short  ncalls);

         该接口使得event变为“激活”状态，激活标志在what中传入（EV_READ, EV_WRITE和EV_TIMEOUT的组合）。该event之前的状态不一定非得要是“挂起”状态，而且将其激活不会使其状态变为“挂起”状态。

         警告：在同一个event上递归调用event_active可能会导致资源耗尽。下面的例子就是不正确的示范：

structevent *ev;

 

static void cb(int  sock,  short which,  void *arg) {

        /* Whoops: Calling event_active on thesame event unconditionally

          from within its callback means that no other eventsmight not get

           run!*/

        event_active(ev,  EV_WRITE,  0);

}

 

int  main(int  argc,  char**argv) {

        struct  event_base *base = event_base_new();

        ev = event_new(base,  -1,  EV_PERSIST| EV_READ,  cb, NULL);

        event_add(ev, NULL);

        event_active(ev, EV_WRITE, 0);

        event_base_loop(base, 0);

        return 0;

}

         上面的例子描述了这样的情形：event loop仅被执行一次，而cb会被无限的递归调用中。

Example:Alternative solution to the above problem using timers

 

struct event *ev;

struct timeval tv;

 

static void  cb(int  sock,short  which,  void *arg) {

   if (!evtimer_pending(ev, NULL)) {

       event_del(ev);

       evtimer_add(ev, &tv);

   }

}

 

int  main(int  argc,  char**argv) {

   struct  event_base  *base = event_base_new();

   tv.tv_sec = 0;

   tv.tv_usec = 0;

 

   ev = evtimer_new(base,  cb,  NULL);

   evtimer_add(ev, &tv);

   event_base_loop(base, 0);

   return 0;

}

 

Example:Alternative solution to the above problem usingevent_config_set_max_dispatch_interval()

 

structevent *ev;

 

static void  cb(int  sock, short  which,  void*arg) {

        event_active(ev,  EV_WRITE,  0);

}

 

intmain(int argc,  char **argv) {

        struct  event_config  *cfg = event_config_new();

        /* Run at most 16 callbacks beforechecking for other events. */

       event_config_set_max_dispatch_interval(cfg,  NULL,  16, 0);

        struct  event_base *base =event_base_new_with_config(cfg);

        ev = event_new(base,  -1,  EV_PERSIST| EV_READ,  cb,  NULL);

 

        event_add(ev, NULL);

        event_active(ev, EV_WRITE, 0);

        event_base_loop(base, 0);

 

        return 0;

}

         该方法在 <event2/event.h>中定义。

 

十三：优化一般性超时

         当前版本的Libevent使用二叉堆算法来对”挂起”状态的event超时时间值进行跟踪。对于有序的添加和删除event超时时间的操作，二叉堆算法可以提供O(lg n)的性能。这对于添加随机分布的超时时间来说，性能是最优的，但是如果是大量相同时间的events来说就不是了。

         比如，假设有一万个事件，每一个event的超时时间都是在他们被添加之后的5秒钟。在这种情况下，使用双向队列实现的话，可以达到O(1)的性能。

 

         正常情况下，一般不希望使用队列管理所有的超时时间值，因为队列仅对于恒定的超时时间来说是快速的。如果一些超时时间或多或少的随机分布的话，那添加这些超时时间到队列将会花费O(n)的时间，这样的性能要比二叉堆差多了。

         Libevent解决这种问题的方法是将一些超时时间值放置在队列中，其他的则放入二叉堆中。可以向Libevent请求一个“公用超时时间”的时间值，然后使用该时间值进行事件的添加。如果存在大量的event，它们的超时时间都是这种单一公用超时时间的情况，那么使用这种优化的方法可以明显提高超时事件的性能。

const struct  timeval * event_base_init_common_timeout(

     struct event_base *base,  const  struct  timeval* duration);

         该方法的参数有event_base，以及一个用来初始化的公用超时时间值。该函数返回一个指向特殊timeval结构体的指针，可以使用该指针表明将event添加到O(1)的队列中，而不是O(lg n)的堆中。这个特殊的timeval结构可以在代码中自由的复制和分配。该timeval只能工作在特定的event_base上（参数）。不要依赖于该timeval的实际值：Libevent仅使用它们来指明使用哪个队列。

#include <event2/event.h>

#include <string.h>

 

/*We're going to create a verylarge number of events on a given base,

 * nearly all of which have a ten-secondtimeout. If initialize_timeout

 * is called, we'll tell Libevent to add theten-second ones to an O(1)

 * queue. */

struct timeval  ten_seconds = { 10, 0 };

 

void  initialize_timeout(struct  event_base *base)

{

    struct  timeval  tv_in = { 10, 0 };

    const  struct  timeval*tv_out;

   tv_out =event_base_init_common_timeout(base, &tv_in);

   memcpy(&ten_seconds,tv_out, sizeof(struct timeval));

}

 

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

{

    /* Note that ev must have the sameevent_base that we passed to

       initialize_timeout */

   if (tv && tv->tv_sec == 10 && tv->tv_usec == 0)

        return event_add(ev, &ten_seconds);

    else

        return event_add(ev, tv);

}

         类似于其他所有的优化函数，除非确定对你有用，否则应该避免使用这种公用超时时间功能。

 

十四：从已清除的内存识别事件

         Libevent提供了这样的函数，可以从已经清0的内存中（比如以calloc分配，或者通过memset或bzero清除）识别出已初始化的event。

int  event_initialized(const  struct  event*ev);

 

#define evsignal_initialized(ev)  event_initialized(ev)

#define evtimer_initialized(ev)  event_initialized(ev)

         警告：这些函数不能在一块未初始化的内存中识别出已经初始化了的event。除非你能确定该内存要么被清0，要么被初始化为event，否则不要使用这些函数。

         一般情况下，除非你的应用程序有着极为特殊的需求，否则不要轻易使用这些函数。通过event_new返回的events永远已经初始化过的。

#include <event2/event.h>

#include <stdlib.h>

 

struct reader {

    evutil_socket_t  fd;

};

 

#defineREADER_ACTUAL_SIZE()  (sizeof(struct  reader) + event_get_struct_event_size())

#defineREADER_EVENT_PTR(r)  ((struct  event *) (((char*)(r))+sizeof(struct  reader)))

 

struct reader * allocate_reader(evutil_socket_t fd)

{

    struct  reader *r = calloc(1, READER_ACTUAL_SIZE());

    if (r)

        r->fd = fd;

    return r;

}

 

void  readcb(evutil_socket_t,  short,  void*);

int  add_reader(struct  reader *r, struct  event_base *b)

{

    struct  event  *ev= READER_EVENT_PTR(r);

    if (!event_initialized(ev))

        event_assign(ev,  b,  r->fd,  EV_READ,  readcb,  r);

    return  event_add(ev, NULL);

}

 

十五：过时的event处理函数

         在Libevent2.0之前的版本中，没有event_assign或者event_new函数，而只有event_set函数，该函数返回的event与“当前”base相关联。如果有多个event_base，则还需要调用event_base_set函数指明event与哪个base相关联。

void  event_set(struct  event  *event, evutil_socket_t  fd,  short what,

        void(*callback)(evutil_socket_t,  short,  void *),  void *arg);

int  event_base_set(struct  event_base * base,  struct  event *event);

         event_set函数类似于event_assign，除了它使用“当前”base的概念。event_base_set函数改变event所关联的base。

         如果是处理超时或者信号events，event_set也有一些便于使用的变种：evtimer_set类似于evtimer_assign，而evsignal_set类似于evsignal_assign。

 

         Libevent2.0之前的版本中，使用以signal_为前缀的函数作为处理基于信号的event_set的变种。而不是evsignal_（也就是说是：signal_set, signal_add, signal_del, signal_pending和signal_intialized）。Libevent古老版本（0.6之前），使用timeout_，而不是evtimer_前缀。因此，如果你需要处理很老的代码的话，可能会看见timeout_add(), timeout_del(), timeout_initialized(),  timeout_set(),  timeout_pending()等。

 

         较老版本的Libevent（2.0之前）使用两个宏，完成event_get_fd和event_get_signal的工作：EVENT_FD和EVENT_SIGNAL。这些宏直接监测event结构的内部，因此在各种版本之间不具有二进制兼容性。在2.0以及之后的版本中，这些宏就是event_get_fd和event_get_signal函数的别名。

 

         在Libevent2.0之前的版本中不支持锁操作，因此，在运行base的线程之外的线程中，调用任何改变event状态的函数，都是不安全的。这些函数包括：event_add, event_del, event_active, and event_base_once。

 

         event_base_once的古老版本是event_once，它使用“当前”base的概念。

         在Libevent2.0之前，超时事件设置EV_PERSISIT是不明智的。并非在event激活时重置超时时间，EV_PERSISIT标志对于超时而言无任何作用。

         Libevent2.0之前的版本不支持多个events，在同一时间添加同样的fd以及相同的READ/WRITE事件。换句话说，对于每一个fd，一次只能有一个event在其上等待读或写。

 

 

http://www.wangafu.net/~nickm/libevent-book/Ref4_event.html