OpenMPI 0.1.1

- Main Page
- Related Pages
- Modules
- Data Structures
- Files

- File List
- Globals

Macros | Typedefs | Enumerations | Functions
event.h File Reference

Core functions for waiting for and receiving events, and using event bases. More...

`#include "opal_rename.h"`
`#include <event2/event-config.h>`
`#include <stdio.h>`
`#include <event2/util.h>`

Go to the source code of this file.

## Macros
#define | event_get_signal(ev) ((int)event_get_fd(ev))
| Get the signal number assigned to a signal event.
#define | LIBEVENT_VERSION _EVENT_VERSION
| As event_get_version, but gives the version of Libevent's headers. More...
#define | LIBEVENT_VERSION_NUMBER _EVENT_NUMERIC_VERSION
| As event_get_version_number, but gives the version number of Libevent's headers. More...
#define | EVENT_MAX_PRIORITIES 256
| Largest number of priorities that Libevent can support. More...
#define | EVENT_SET_MEM_FUNCTIONS_IMPLEMENTED
| This definition is present if Libevent was built with support for event_set_mem_functions()
Log severities
#define | _EVENT_LOG_DEBUG 0
#define | _EVENT_LOG_MSG 1
#define | _EVENT_LOG_WARN 2
#define | _EVENT_LOG_ERR 3
Loop flags
These flags control the behavior of event_base_loop().
#define | EVLOOP_ONCE 0x01
| Block until we have an active event, then exit once all active events have had their callbacks run. More...
#define | EVLOOP_NONBLOCK 0x02
| Do not block: see which events are ready now, run the callbacks of the highest-priority ones, then exit. More...
event flags
Flags to pass to event_new(), event_assign(), event_pending(), and anything else with an argument of the form "short events"
#define | EV_TIMEOUT 0x01
| Indicates that a timeout has occurred. More...
#define | EV_READ 0x02
| Wait for a socket or FD to become readable.
#define | EV_WRITE 0x04
| Wait for a socket or FD to become writeable.
#define | EV_SIGNAL 0x08
| Wait for a POSIX signal to be raised.
#define | EV_PERSIST 0x10
| Persistent event: won't get removed automatically when activated. More...
#define | EV_ET 0x20
| Select edge-triggered behavior, if supported by the backend. More...
evtimer_* macros
Aliases for working with one-shot timer events
#define | evtimer_assign(ev, b, cb, arg) event_assign((ev), (b), -1, 0, (cb), (arg))
#define | evtimer_new(b, cb, arg) event_new((b), -1, 0, (cb), (arg))
#define | evtimer_add(ev, tv) event_add((ev), (tv))
#define | evtimer_del(ev) event_del(ev)
#define | evtimer_pending(ev, tv) event_pending((ev), EV_TIMEOUT, (tv))
#define | evtimer_initialized(ev) event_initialized(ev)
evsignal_* macros
Aliases for working with signal events
#define | evsignal_add(ev, tv) event_add((ev), (tv))
#define | evsignal_assign(ev, b, x, cb, arg) event_assign((ev), (b), (x), EV_SIGNAL|EV_PERSIST, cb, (arg))
#define | evsignal_new(b, x, cb, arg) event_new((b), (x), EV_SIGNAL|EV_PERSIST, (cb), (arg))
#define | evsignal_del(ev) event_del(ev)
#define | evsignal_pending(ev, tv) event_pending((ev), EV_SIGNAL, (tv))
#define | evsignal_initialized(ev) event_initialized(ev)

## Typedefs
typedef void(* | event_log_cb )(int severity, const char *msg)
| A callback function used to intercept Libevent's log messages. More...
typedef void(* | event_fatal_cb )(int err)
| A function to be called if Libevent encounters a fatal internal error. More...
typedef void(* | event_callback_fn )(evutil_socket_t, short, void *)
| A callback function for an event. More...

## Enumerations
enum | event_method_feature { EV_FEATURE_ET = 0x01, EV_FEATURE_O1 = 0x02, EV_FEATURE_FDS = 0x04 }
| A flag used to describe which features an event_base (must) provide. More...
enum | event_base_config_flag { EVENT_BASE_FLAG_NOLOCK = 0x01, EVENT_BASE_FLAG_IGNORE_ENV = 0x02, EVENT_BASE_FLAG_STARTUP_IOCP = 0x04, EVENT_BASE_FLAG_NO_CACHE_TIME = 0x08, EVENT_BASE_FLAG_EPOLL_USE_CHANGELIST = 0x10 }
| A flag passed to event_config_set_flag(). More...

## Functions
void | event_enable_debug_mode (void)
| Enable some relatively expensive debugging checks in Libevent that would normally be turned off. More...
void | event_set_debug_output (int output)
void | event_debug_unassign (struct event *)
| When debugging mode is enabled, informs Libevent that an event should no longer be considered as assigned. More...
struct event_base * | event_base_new (void)
| Create and return a new event_base to use with the rest of Libevent. More...
int | event_reinit (struct event_base *base)
| Reinitialize the event base after a fork. More...
int | event_base_dispatch (struct event_base *)
| Event dispatching loop. More...
const char * | event_base_get_method (const struct event_base *)
| Get the kernel event notification mechanism used by Libevent. More...
const char ** | event_get_supported_methods (void)
| Gets all event notification mechanisms supported by Libevent. More...
struct event_config * | event_config_new (void)
| Allocates a new event configuration object. More...
void | event_config_free (struct event_config *cfg)
| Deallocates all memory associated with an event configuration object. More...
int | event_config_avoid_method (struct event_config *cfg, const char *method)
| Enters an event method that should be avoided into the configuration. More...
int | event_base_get_features (const struct event_base *base)
| Return a bitmask of the features implemented by an event base. More...
int | event_config_require_features (struct event_config *cfg, int feature)
| Enters a required event method feature that the application demands. More...
int | event_config_set_flag (struct event_config *cfg, int flag)
| Sets one or more flags to configure what parts of the eventual event_base will be initialized, and how they'll work. More...
int | event_config_set_num_cpus_hint (struct event_config *cfg, int cpus)
| Records a hint for the number of CPUs in the system. More...
struct event_base * | event_base_new_with_config (const struct event_config *)
| Initialize the event API. More...
void | event_base_free (struct event_base *)
| Deallocate all memory associated with an event_base, and free the base. More...
void | event_set_log_callback (event_log_cb cb)
| Redirect Libevent's log messages. More...
void | event_set_fatal_callback (event_fatal_cb cb)
| Override Libevent's behavior in the event of a fatal internal error. More...
int | event_base_set (struct event_base *, struct event *)
| Associate a different event base with an event. More...
int | event_base_loop (struct event_base *, int)
| Wait for events to become active, and run their callbacks. More...
int | event_base_loopexit (struct event_base *, const struct timeval *)
| Exit the event loop after the specified time. More...
int | event_base_loopbreak (struct event_base *)
| Abort the active event_base_loop() immediately. More...
int | event_base_got_exit (struct event_base *)
| Checks if the event loop was told to exit by event_loopexit(). More...
int | event_base_got_break (struct event_base *)
| Checks if the event loop was told to abort immediately by event_loopbreak(). More...
struct event * | event_new (struct event_base *, evutil_socket_t, short, event_callback_fn, void *)
| Allocate and asssign a new event structure, ready to be added. More...
int | event_assign (struct event *, struct event_base *, evutil_socket_t, short, event_callback_fn, void *)
| Prepare a new, already-allocated event structure to be added. More...
void | event_free (struct event *)
| Deallocate a struct event * returned by event_new(). More...
int | event_base_once (struct event_base *, evutil_socket_t, short, event_callback_fn, void *, const struct timeval *)
| Schedule a one-time event. More...
int | event_add (struct event *ev, const struct timeval *timeout)
| Add an event to the set of pending events. More...
int | event_del (struct event *)
| Remove an event from the set of monitored events. More...
void | event_active (struct event *ev, int res, short ncalls)
| Make an event active. More...
int | event_pending (const struct event *ev, short events, struct timeval *tv)
| Checks if a specific event is pending or scheduled. More...
int | event_initialized (const struct event *ev)
| Test if an event structure might be initialized. More...
evutil_socket_t | event_get_fd (const struct event *ev)
| Get the socket or signal assigned to an event, or -1 if the event has no socket.
struct event_base * | event_get_base (const struct event *ev)
| Get the event_base associated with an event.
short | event_get_events (const struct event *ev)
| Return the events (EV_READ, EV_WRITE, etc) assigned to an event.
event_callback_fn | event_get_callback (const struct event *ev)
| Return the callback assigned to an event.
void * | event_get_callback_arg (const struct event *ev)
| Return the callback argument assigned to an event.
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)
| Extract all of arguments given to construct a given event. More...
size_t | event_get_struct_event_size (void)
| Return the size of struct event that the Libevent library was compiled with. More...
const char * | event_get_version (void)
| Get the Libevent version. More...
ev_uint32_t | event_get_version_number (void)
| Return a numeric representation of Libevent's version. More...
int | event_base_priority_init (struct event_base *, int)
| Set the number of different event priorities. More...
int | event_priority_set (struct event *, int)
| Assign a priority to an event. More...
const struct timeval * | event_base_init_common_timeout (struct event_base *base, const struct timeval *duration)
| Prepare an event_base to use a large number of timeouts with the same duration. More...
void | event_set_mem_functions (void *(*malloc_fn)(size_t sz), void *(*realloc_fn)(void *ptr, size_t sz), void(*free_fn)(void *ptr))
| Override the functions that Libevent uses for memory management. More...
void | event_base_dump_events (struct event_base *, FILE *)
int | event_base_gettimeofday_cached (struct event_base *base, struct timeval *tv)
| Sets 'tv' to the current time (as returned by gettimeofday()), looking at the cached value in 'base' if possible, and calling gettimeofday() or clock_gettime() as appropriate if there is no cached time. More...

## Detailed Description

Core functions for waiting for and receiving events, and using event bases.

## Macro Definition Documentation

#define EV_ET 0x20

Select edge-triggered behavior, if supported by the backend.

Referenced by evmap_io_add().

#define EV_PERSIST 0x10

Persistent event: won't get removed automatically when activated.

When a persistent event with a timeout becomes activated, its timeout is reset to 0.

Referenced by bufferevent_rate_limit_group_new(), bufferevent_socket_connect(), bufferevent_socket_new(), evdns_add_server_port_with_base(), evdns_server_request_respond(), event_assign(), event_base_once(), and evthread_make_base_notifiable().

#define EV_TIMEOUT 0x01

Indicates that a timeout has occurred.

It's not necessary to pass this flag to event_for new()/event_assign() to get a timeout.

Referenced by event_base_loopexit(), event_base_once(), event_loopexit(), and event_pending().

#define EVENT_MAX_PRIORITIES 256

Largest number of priorities that Libevent can support.

Referenced by event_base_priority_init().

#define EVLOOP_NONBLOCK 0x02

Do not block: see which events are ready now, run the callbacks of the highest-priority ones, then exit.

Referenced by event_base_loop().

#define EVLOOP_ONCE 0x01

Block until we have an active event, then exit once all active events have had their callbacks run.

Referenced by event_base_loop().

#define LIBEVENT_VERSION _EVENT_VERSION

As event_get_version, but gives the version of Libevent's headers.

#define LIBEVENT_VERSION_NUMBER _EVENT_NUMERIC_VERSION

As event_get_version_number, but gives the version number of Libevent's headers.

## Typedef Documentation

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

A callback function for an event.

It receives three arguments:

Parameters

  fd | An fd or signal
  events | One or more EV_* flags
  arg | A user-supplied argument.

See also
  event_new()

typedef void(* event_fatal_cb)(int err)

A function to be called if Libevent encounters a fatal internal error.

See also
  event_set_fatal_callback

typedef void(* event_log_cb)(int severity, const char *msg)

A callback function used to intercept Libevent's log messages.

See also
  event_set_log_callback

## Enumeration Type Documentation

enum event_base_config_flag

A flag passed to event_config_set_flag().

These flags change the behavior of an allocated event_base.

See also
  event_config_set_flag(), event_base_new_with_config(), event_method_feature

Enumerator
EVENT_BASE_FLAG_NOLOCK | Do not allocate a lock for the event base, even if we have locking set up.
EVENT_BASE_FLAG_IGNORE_ENV | Do not check the EVENT_* environment variables when configuring an event_base.
EVENT_BASE_FLAG_STARTUP_IOCP | Windows only: enable the IOCP dispatcher at startup. If this flag is set then bufferevent_socket_new() and evconn_listener_new() will use IOCP-backed implementations instead of the usual select-based one on Windows.
EVENT_BASE_FLAG_NO_CACHE_TIME | Instead of checking the current time every time the event loop is ready to run timeout callbacks, check after each timeout callback.
EVENT_BASE_FLAG_EPOLL_USE_CHANGELIST | If we are using the epoll backend, this flag says that it is safe to use Libevent's internal change-list code to batch up adds and deletes in order to try to do as few syscalls as possible. Setting this flag can make your code run faster, but it may trigger a Linux bug: it is not safe to use this flag if you have any fds cloned by dup() or its variants. Doing so will produce strange and hard-to-diagnose bugs. This flag can also be activated by settnig the EVENT_EPOLL_USE_CHANGELIST environment variable. This flag has no effect if you wind up using a backend other than epoll.

enum event_method_feature

A flag used to describe which features an event_base (must) provide.

Because of OS limitations, not every Libevent backend supports every possible feature. You can use this type with event_config_require_features() to tell Libevent to only proceed if your event_base implements a given feature, and you can receive this type from event_base_get_features() to see which features are available.

Enumerator
EV_FEATURE_ET | Require an event method that allows edge-triggered events with EV_ET.
EV_FEATURE_O1 | Require an event method where having one event triggered among many is [approximately] an O(1) operation. This excludes (for example) select and poll, which are approximately O(N) for N equal to the total number of possible events.
EV_FEATURE_FDS | Require an event method that allows file descriptors as well as sockets.

## Function Documentation

void event_active | ( | struct event * | ev,
|  | int | res,
|  | short | ncalls
| ) |  |

Make an event active.

You can use this function on a pending or a non-pending event to make it active, so that its callback will be run by event_base_dispatch() or event_base_loop().

One common use in multithreaded programs is to wake the thread running event_base_loop() from another thread.

Parameters

  ev | an event to make active.
  res | a set of flags to pass to the event's callback.
  ncalls | an obsolete argument: this is ignored.

References event_base::th_base_lock.

Referenced by bufferevent_socket_connect().

int event_add | ( | struct event * | ev,
|  | const struct timeval * | timeout
| ) |  |

Add an event to the set of pending events.

The function event_add() schedules the execution of the ev event when the event specified in event_assign()/event_new() occurs, or when the time specified in timeout has elapesed. If atimeout is NULL, no timeout occurs and the function will only be called if a matching event occurs. The event in the ev argument must be already initialized by event_assign() or event_new() and may not be used in calls to event_assign() until it is no longer pending.

If the event in the ev argument already has a scheduled timeout, calling event_add() replaces the old timeout with the new one, or clears the old timeout if the timeout argument is NULL.

Parameters

  ev | an event struct initialized via event_set()
  timeout | the maximum amount of time to wait for the event, or NULL to wait forever

Returns
  0 if successful, or -1 if an error occurred

See also
  event_del(), event_assign(), event_new()

References event_base::th_base_lock.

Referenced by bufferevent_rate_limit_group_new(), bufferevent_rate_limit_group_set_cfg(), bufferevent_set_rate_limit(), evdns_add_server_port_with_base(), evdns_server_request_respond(), event_base_once(), and evthread_make_base_notifiable().

int event_assign | ( | struct event * | ,
|  | struct event_base * | ,
|  | evutil_socket_t | ,
|  | short | ,
|  | event_callback_fn | ,
|  | void * |
| ) |  |

Prepare a new, already-allocated event structure to be added.

The function event_assign() prepares the event structure ev to be used in future calls to event_add() and event_del(). Unlike event_new(), it doesn't allocate memory itself: it requires that you have already allocated a struct event, probably on the heap. Doing this will typically make your code depend on the size of the event structure, and thereby create incompatibility with future versions of Libevent.

The easiest way to avoid this problem is just to use event_new() and event_free() instead.

A slightly harder way to future-proof your code is to use event_get_struct_event_size() to determine the required size of an event at runtime.

Note that it is NOT safe to call this function on an event that is active or pending. Doing so WILL corrupt internal data structures in Libevent, and lead to strange, hard-to-diagnose bugs. You can use event_assign to change an existing event, but only if it is not active or pending!

The arguments for this function, and the behavior of the events that it makes, are as for event_new().

Parameters

  ev | an event struct to be modified
  base | the event base to which ev should be attached.
  fd | the file descriptor to be monitored
  events | desired events to monitor; can be EV_READ and/or EV_WRITE
  callback | callback function to be invoked when the event occurs
  callback_arg | an argument to be passed to the callback function

Returns
  0 if success, or -1 on invalid arguments.

See also
  event_new(), event_add(), event_del(), event_base_once(), event_get_struct_event_size()

References EV_PERSIST, EV_READ, EV_SIGNAL, EV_WRITE, and event_base::nactivequeues.

Referenced by bufferevent_rate_limit_group_new(), bufferevent_socket_connect(), bufferevent_socket_new(), evdns_add_server_port_with_base(), evdns_server_request_respond(), event_base_once(), event_new(), event_set(), and evthread_make_base_notifiable().

int event_base_dispatch | ( | struct event_base * |  | ) |

Event dispatching loop.

This loop will run the event base until either there are no more added events, or until something calls event_base_loopbreak() or event_base_loopexit().

Parameters

  base | the event_base structure returned by event_base_new() or event_base_new_with_config()

Returns
  0 if successful, -1 if an error occurred, or 1 if no events were registered.

See also
  event_base_loop()

References event_base_loop().

void event_base_free | ( | struct event_base * |  | ) |

Deallocate all memory associated with an event_base, and free the base.

Note that this function will not close any fds or free any memory passed to event_new as the argument to callback.

Parameters

  eb | an event_base to be freed

References event_base::activequeues, event_base::changelist, event_base::common_timeout_queues, event_base::current_event_cond, eventop::dealloc, event_debug_unassign(), event_del(), event_base::eventqueue, evmap_io_clear(), event_base::evsel, EVTHREAD_LOCKTYPE_RECURSIVE, event_base::io, event_base::n_common_timeouts, event_base::nactivequeues, event_base::sigmap, event_base::th_base_lock, event_base::th_notify, event_base::th_notify_fd, and event_base::timeheap.

Referenced by event_base_new_with_config().

int event_base_get_features | ( | const struct event_base * | base | ) |

Return a bitmask of the features implemented by an event base.

This will be a bitwise OR of one or more of the values of event_method_feature

See also
  event_method_feature

References event_base::evsel, and eventop::features.

const char* event_base_get_method | ( | const struct event_base * |  | ) |

Get the kernel event notification mechanism used by Libevent.

Parameters

  eb | the event_base structure returned by event_base_new()

Returns
  a string identifying the kernel event mechanism (kqueue, epoll, etc.)

References event_base::evsel, and eventop::name.

int event_base_gettimeofday_cached | ( | struct event_base * | base,
|  | struct timeval * | tv
| ) |  |

Sets 'tv' to the current time (as returned by gettimeofday()), looking at the cached value in 'base' if possible, and calling gettimeofday() or clock_gettime() as appropriate if there is no cached time.

Generally, this value will only be cached while actually processing event callbacks, and may be very inaccuate if your callbacks take a long time to execute.

Returns 0 on success, negative on failure.

References event_base::tv_cache.

Referenced by bufferevent_rate_limit_group_new(), and bufferevent_set_rate_limit().

int event_base_got_break | ( | struct event_base * |  | ) |

Checks if the event loop was told to abort immediately by event_loopbreak().

This function will return true for an event_base at every point after event_loopbreak() is called, until the event loop is next entered.

Parameters

  eb | the event_base structure returned by event_init()

Returns
  true if event_base_loopbreak() was called on this event base, or 0 otherwise

See also
  event_base_loopbreak()
  event_base_got_exit()

References event_base::event_break, and event_base::th_base_lock.

int event_base_got_exit | ( | struct event_base * |  | ) |

Checks if the event loop was told to exit by event_loopexit().

This function will return true for an event_base at every point after event_loopexit() is called, until the event loop is next entered.

Parameters

  eb | the event_base structure returned by event_init()

Returns
  true if event_base_loopexit() was called on this event base, or 0 otherwise

See also
  event_base_loopexit()
  event_base_got_break()

References event_base::event_gotterm, and event_base::th_base_lock.

const struct timeval* event_base_init_common_timeout | ( | struct event_base * | base,
|  | const struct timeval * | duration
| ) |  |

Prepare an event_base to use a large number of timeouts with the same duration.

Libevent's default scheduling algorithm is optimized for having a large number of timeouts with their durations more or less randomly distributed. But if you have a large number of timeouts that all have the same duration (for example, if you have a large number of connections that all have a 10-second timeout), then you can improve Libevent's performance by telling Libevent about it.

To do this, call this function with the common duration. It will return a pointer to a different, opaque timeout value. (Don't depend on its actual contents!) When you use this timeout value in event_add(), Libevent will schedule the event more efficiently.

(This optimization probably will not be worthwhile until you have thousands or tens of thousands of events with the same timeout.)

References event_base::common_timeout_queues, event_priority_set(), event_base::n_common_timeouts, and event_base::n_common_timeouts_allocated.

int event_base_loop | ( | struct event_base * | ,
|  | int |
| ) |  |

Wait for events to become active, and run their callbacks.

This is a more flexible version of event_base_dispatch().

By default, this loop will run the event base until either there are no more added events, or until something calls event_base_loopbreak() or evenet_base_loopexit(). You can override this behavior with the 'flags' argument.

Parameters

  eb | the event_base structure returned by event_base_new() or event_base_new_with_config()
  flags | any combination of EVLOOP_ONCE | EVLOOP_NONBLOCK

Returns
  0 if successful, -1 if an error occurred, or 1 if no events were registered.

See also
  event_base_loopexit(), event_base_dispatch(), EVLOOP_ONCE, EVLOOP_NONBLOCK

References eventop::dispatch, event_base::event_break, event_base::event_gotterm, event_base::event_tv, EVLOOP_NONBLOCK, EVLOOP_ONCE, event_base::evsel, event_base::running_loop, event_base::sig, and event_base::th_owner_id.

Referenced by event_base_dispatch(), and event_loop().

int event_base_loopbreak | ( | struct event_base * |  | ) |

Abort the active event_base_loop() immediately.

event_base_loop() will abort the loop after the next event is completed; event_base_loopbreak() is typically invoked from this event's callback. This behavior is analogous to the "break;" statement.

Subsequent invocations of event_loop() will proceed normally.

Parameters

  eb | the event_base structure returned by event_init()

Returns
  0 if successful, or -1 if an error occurred

See also
  event_base_loopexit()

References event_base::event_break, and event_base::th_base_lock.

Referenced by event_loopbreak().

int event_base_loopexit | ( | struct event_base * | ,
|  | const struct timeval * |
| ) |  |

Exit the event loop after the specified time.

The next event_base_loop() iteration after the given timer expires will complete normally (handling all queued events) then exit without blocking for events again.

Subsequent invocations of event_base_loop() will proceed normally.

Parameters

  eb | the event_base structure returned by event_init()
  tv | the amount of time after which the loop should terminate, or NULL to exit after running all currently active events.

Returns
  0 if successful, or -1 if an error occurred

See also
  event_base_loopbreak()

References EV_TIMEOUT, and event_base_once().

struct event_base* event_base_new | ( | void |  | ) |

Create and return a new event_base to use with the rest of Libevent.

Returns
  a new event_base on success, or NULL on failure.

See also
  event_base_free(), event_base_new_with_config()

References event_base_new_with_config(), event_config_free(), and event_config_new().

struct event_base* event_base_new_with_config | ( | const struct event_config * |  | ) |

Initialize the event API.

Use event_base_new_with_config() to initialize a new event base, taking the specified configuration under consideration. The configuration object can currently be used to avoid certain event notification mechanisms.

Parameters

  cfg | the event configuration object

Returns
  an initialized event_base that can be used to registering events, or NULL if no event base can be created with the requested event_config.

See also
  event_base_new(), event_base_free(), event_init(), event_assign()

References event_base::changelist, event_base::current_event_cond, event_base::defer_queue, event_base::evbase, EVENT_BASE_FLAG_IGNORE_ENV, EVENT_BASE_FLAG_NOLOCK, EVENT_BASE_FLAG_STARTUP_IOCP, event_base_free(), event_base_priority_init(), event_base::event_tv, event_base::eventqueue, evmap_io_initmap(), event_base::evsel, EVTHREAD_LOCKTYPE_RECURSIVE, evthread_make_base_notifiable(), event_base::flags, eventop::init, event_base::io, deferred_cb_queue::lock, eventop::name, deferred_cb_queue::notify_fn, event_base::sig, event_base::sigmap, event_base::th_base_lock, event_base::th_notify_fd, and event_base::timeheap.

Referenced by event_base_new(), and event_init().

int event_base_once | ( | struct event_base * | ,
|  | evutil_socket_t | ,
|  | short | ,
|  | event_callback_fn | ,
|  | void * | ,
|  | const struct timeval * |
| ) |  |

Schedule a one-time event.

The function event_base_once() is similar to event_set(). However, it schedules a callback to be called exactly once, and does not require the caller to prepare an event structure.

Note that in Libevent 2.0 and earlier, if the event is never triggered, the internal memory used to hold it will never be freed. This may be fixed in a later version of Libevent.

Parameters

  base | an event_base
  fd | a file descriptor to monitor, or -1 for no fd.
  events | event(s) to monitor; can be any of EV_READ | EV_WRITE, or EV_TIMEOUT
  callback | callback function to be invoked when the event occurs
  arg | an argument to be passed to the callback function
  timeout | the maximum amount of time to wait for the event. NULL makes an EV_READ/EV_WRITE event make forever; NULL makes an EV_TIMEOUT event succees immediately.

Returns
  0 if successful, or -1 if an error occurred

References EV_PERSIST, EV_READ, EV_SIGNAL, EV_TIMEOUT, EV_WRITE, event_add(), and event_assign().

Referenced by event_base_loopexit(), and event_once().

int event_base_priority_init | ( | struct event_base * | ,
|  | int |
| ) |  |

Set the number of different event priorities.

By default Libevent schedules all active events with the same priority. However, some time it is desirable to process some events with a higher priority than others. For that reason, Libevent supports strict priority queues. Active events with a lower priority are always processed before events with a higher priority.

The number of different priorities can be set initially with the event_base_priority_init() function. This function should be called before the first call to event_base_dispatch(). The event_priority_set() function can be used to assign a priority to an event. By default, Libevent assigns the middle priority to all events unless their priority is explicitly set.

Note that urgent-priority events can starve less-urgent events: after running all urgent-priority callbacks, Libevent checks for more urgent events again, before running less-urgent events. Less-urgent events will not have their callbacks run until there are no events more urgent than them that want to be active.

Parameters

  eb | the event_base structure returned by event_base_new()
  npriorities | the maximum number of priorities

Returns
  0 if successful, or -1 if an error occurred

See also
  event_priority_set()

References event_base::activequeues, EVENT_MAX_PRIORITIES, and event_base::nactivequeues.

Referenced by event_base_new_with_config(), and event_priority_init().

int event_base_set | ( | struct event_base * | ,
|  | struct event * |
| ) |  |

Associate a different event base with an event.

The event to be associated must not be currently active or pending.

Parameters

  eb | the event base
  ev | the event

Returns
  0 on success, -1 on failure.

References event_base::nactivequeues.

Referenced by bufferevent_base_set().

int event_config_avoid_method | ( | struct event_config * | cfg,
|  | const char * | method
| ) |  |

Enters an event method that should be avoided into the configuration.

This can be used to avoid event mechanisms that do not support certain file descriptor types, or for debugging to avoid certain event mechanisms. An application can make use of multiple event bases to accommodate incompatible file descriptor types.

Parameters

  cfg | the event configuration object
  method | the name of the event method to avoid

Returns
  0 on success, -1 on failure.

void event_config_free | ( | struct event_config * | cfg | ) |

Deallocates all memory associated with an event configuration object.

Parameters

  cfg | the event configuration object to be freed.

Referenced by event_base_new().

struct event_config* event_config_new | ( | void |  | ) |

Allocates a new event configuration object.

The event configuration object can be used to change the behavior of an event base.

Returns
  an event_config object that can be used to store configuration, or NULL if an error is encountered.

See also
  event_base_new_with_config(), event_config_free(), event_config

Referenced by event_base_new().

int event_config_require_features | ( | struct event_config * | cfg,
|  | int | feature
| ) |  |

Enters a required event method feature that the application demands.

Note that not every feature or combination of features is supported on every platform. Code that requests features should be prepared to handle the case where event_base_new_with_config() returns NULL, as in:

      event_config_require_features(cfg, EV_FEATURE_ET);
      base = event_base_new_with_config(cfg);
      if (base == NULL) {
        // We can't get edge-triggered behavior here.
        event_config_require_features(cfg, 0);
        base = event_base_new_with_config(cfg);
      }

Parameters

  cfg | the event configuration object
  feature | a bitfield of one or more event_method_feature values. Replaces values from previous calls to this function.

Returns
  0 on success, -1 on failure.

See also
  event_method_feature, event_base_new_with_config()

int event_config_set_flag | ( | struct event_config * | cfg,
|  | int | flag
| ) |  |

Sets one or more flags to configure what parts of the eventual event_base will be initialized, and how they'll work.

See also
  event_base_config_flags, event_base_new_with_config()

int event_config_set_num_cpus_hint | ( | struct event_config * | cfg,
|  | int | cpus
| ) |  |

Records a hint for the number of CPUs in the system.

This is used for tuning thread pools, etc, for optimal performance. In Libevent 2.0, it is only on Windows, and only when IOCP is in use.

Parameters

  cfg | the event configuration object
  cpus | the number of cpus

Returns
  0 on success, -1 on failure.

void event_debug_unassign | ( | struct event * |  | ) |

When debugging mode is enabled, informs Libevent that an event should no longer be considered as assigned.

When debugging mode is not enabled, does nothing.

This function must only be called on a non-added event.

See also
  event_enable_debug_mode()

Referenced by event_base_free(), event_reinit(), and evhttp_connection_free().

int event_del | ( | struct event * |  | ) |

Remove an event from the set of monitored events.

The function event_del() will cancel the event in the argument ev. If the event has already executed or has never been added the call will have no effect.

Parameters

  ev | an event struct to be removed from the working set

Returns
  0 if successful, or -1 if an error occurred

See also
  event_add()

Referenced by bufferevent_rate_limit_group_free(), bufferevent_set_rate_limit(), evdns_base_clear_nameservers_and_suspend(), evdns_server_request_respond(), event_base_free(), event_free(), and evhttp_connection_free().

void event_enable_debug_mode | ( | void |  | ) |

Enable some relatively expensive debugging checks in Libevent that would normally be turned off.

Generally, these checks cause code that would otherwise crash mysteriously to fail earlier with an assertion failure. Note that this method MUST be called before any events or event_bases have been created.

Debug mode can currently catch the following errors: An event is re-assigned while it is added Any function is called on a non-assigned event

Note that debugging mode uses memory to track every event that has been initialized (via event_assign, event_set, or event_new) but not yet released (via event_free or event_debug_unassign). If you want to use debug mode, and you find yourself running out of memory, you will need to use event_debug_unassign to explicitly stop tracking events that are no longer considered set-up.

See also
  event_debug_unassign()

void event_free | ( | struct event * |  | ) |

Deallocate a struct event * returned by event_new().

If the event is pending or active, first make it non-pending and non-active.

References event_del().

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
| ) |  |

Extract all of arguments given to construct a given event.

The event_base is copied into *base_out, the fd is copied into *fd_out, and so on.

If any of the "_out" arguments is NULL, it will be ignored.

size_t event_get_struct_event_size | ( | void |  | ) |

Return the size of struct event that the Libevent library was compiled with.

This will be NO GREATER than sizeof(struct event) if you're running with the same version of Libevent that your application was built with, but otherwise might not.

Note that it might be SMALLER than sizeof(struct event) if some future version of Libevent adds extra padding to the end of struct event. We might do this to help ensure ABI-compatibility between different versions of Libevent.

const char** event_get_supported_methods | ( | void |  | ) |

Gets all event notification mechanisms supported by Libevent.

This functions returns the event mechanism in order preferred by Libevent. Note that this list will include all backends that Libevent has compiled-in support for, and will not necessarily check your OS to see whether it has the required resources.

Returns
  an array with pointers to the names of support methods. The end of the array is indicated by a NULL pointer. If an error is encountered NULL is returned.

References eventop::name.

const char* event_get_version | ( | void |  | ) |

Get the Libevent version.

Note that this will give you the version of the library that you're currently linked against, not the version of the headers that you've compiled against.

Returns
  a string containing the version number of Libevent

ev_uint32_t event_get_version_number | ( | void |  | ) |

Return a numeric representation of Libevent's version.

Note that this will give you the version of the library that you're currently linked against, not the version of the headers you've used to compile.

The format uses one byte each for the major, minor, and patchlevel parts of the version number. The low-order byte is unused. For example, version 2.0.1-alpha has a numeric representation of 0x02000100

int event_initialized | ( | const struct event * | ev | ) |

Test if an event structure might be initialized.

The event_initialized() function can be used to check if an event has been initialized.

Warning: This function is only useful for distinguishing a a zeroed-out piece of memory from an initialized event, it can easily be confused by uninitialized memory. Thus, it should ONLY be used to distinguish an initialized event from zero.

Parameters

  ev | an event structure to be tested

Returns
  1 if the structure might be initialized, or 0 if it has not been initialized

Referenced by bufferevent_set_rate_limit(), and evhttp_connection_free().

struct event* event_new | ( | struct event_base * | ,
|  | evutil_socket_t | ,
|  | short | ,
|  | event_callback_fn | ,
|  | void * |
| ) |  |

Allocate and asssign a new event structure, ready to be added.

The function event_new() returns a new event that can be used in future calls to event_add() and event_del(). The fd and events arguments determine which conditions will trigger the event; the callback and callback_arg arguments tell Libevent what to do when the event becomes active.

If events contains one of EV_READ, EV_WRITE, or EV_READ|EV_WRITE, then fd is a file descriptor or socket that should get monitored for readiness to read, readiness to write, or readiness for either operation (respectively). If events contains EV_SIGNAL, then fd is a signal number to wait for. If events contains none of those flags, then the event can be triggered only by a timeout or by manual activation with event_active(): In this case, fd must be -1.

The EV_PERSIST flag can also be passed in the events argument: it makes event_add() persistent until event_del() is called.

The EV_ET flag is compatible with EV_READ and EV_WRITE, and supported only by certain backends. It tells Libevent to use edge-triggered events.

The EV_TIMEOUT flag has no effect here.

It is okay to have multiple events all listening on the same fds; but they must either all be edge-triggered, or all not be edge triggerd.

When the event becomes active, the event loop will run the provided callbuck function, with three arguments. The first will be the provided fd value. The second will be a bitfield of the events that triggered: EV_READ, EV_WRITE, or EV_SIGNAL. Here the EV_TIMEOUT flag indicates that a timeout occurred, and EV_ET indicates that an edge-triggered event occurred. The third event will be the callback_arg pointer that you provide.

Parameters

  base | the event base to which the event should be attached.
  fd | the file descriptor or signal to be monitored, or -1.
  events | desired events to monitor: bitfield of EV_READ, EV_WRITE, EV_SIGNAL, EV_PERSIST, EV_ET.
  callback | callback function to be invoked when the event occurs
  callback_arg | an argument to be passed to the callback function

Returns
  a newly allocated struct event that must later be freed with event_free().

See also
  event_free(), event_add(), event_del(), event_assign()

References event_assign().

int event_pending | ( | const struct event * | ev,
|  | short | events,
|  | struct timeval * | tv
| ) |  |

Checks if a specific event is pending or scheduled.

Parameters

  ev | an event struct previously passed to event_add()
  events | the requested event type; any of EV_TIMEOUT|EV_READ| EV_WRITE|EV_SIGNAL
  tv | if this field is not NULL, and the event has a timeout, this field is set to hold the time at which the timeout will expire.

Returns
  true if the event is pending on any of the events in 'what', (that is to say, it has been added), or 0 if the event is not added.

References EV_READ, EV_SIGNAL, EV_TIMEOUT, and EV_WRITE.

int event_priority_set | ( | struct event * | ,
|  | int |
| ) |  |

Assign a priority to an event.

Parameters

  ev | an event struct
  priority | the new priority to be assigned

Returns
  0 if successful, or -1 if an error occurred

See also
  event_priority_init()

References event_base::nactivequeues.

Referenced by bufferevent_priority_set(), event_base_init_common_timeout(), and evthread_make_base_notifiable().

int event_reinit | ( | struct event_base * | base | ) |

Reinitialize the event base after a fork.

Some event mechanisms do not survive across fork. The event base needs to be reinitialized with the event_reinit() function.

Parameters

  base | the event base that needs to be re-initialized

Returns
  0 if successful, or -1 if some events could not be re-added.

See also
  event_base_new()

References event_base::changelist, eventop::dealloc, EV_READ, EV_SIGNAL, EV_WRITE, event_base::evbase, event_debug_unassign(), event_base::eventqueue, evmap_io_add(), evmap_io_clear(), event_base::evsel, evthread_make_base_notifiable(), eventop::init, event_base::io, eventop::need_reinit, event_base::sig, event_base::sigmap, event_base::th_notify, and event_base::th_notify_fd.

void event_set_fatal_callback | ( | event_fatal_cb | cb | ) |

Override Libevent's behavior in the event of a fatal internal error.

By default, Libevent will call exit(1) if a programming error makes it impossible to continue correct operation. This function allows you to supply another callback instead. Note that if the function is ever invoked, something is wrong with your program, or with Libevent: any subsequent calls to Libevent may result in undefined behavior.

Libevent will (almost) always log an _EVENT_LOG_ERR message before calling this function; look at the last log message to see why Libevent has died.

void event_set_log_callback | ( | event_log_cb | cb | ) |

Redirect Libevent's log messages.

Parameters

  cb | a function taking two arguments: an integer severity between _EVENT_LOG_DEBUG and _EVENT_LOG_ERR, and a string. If cb is NULL, then the default log is used.

NOTE: The function you provide must not call any other libevent functionality. Doing so can produce undefined behavior.

void event_set_mem_functions | ( | void *(*)(size_t sz) | malloc_fn,
|  | void *(*)(void *ptr, size_t sz) | realloc_fn,
|  | void(*)(void *ptr) | free_fn
| ) |  |

Override the functions that Libevent uses for memory management.

Usually, Libevent uses the standard libc functions malloc, realloc, and free to allocate memory. Passing replacements for those functions to event_set_mem_functions() overrides this behavior.

Note that all memory returned from Libevent will be allocated by the replacement functions rather than by malloc() and realloc(). Thus, if you have replaced those functions, it will not be appropriate to free() memory that you get from Libevent. Instead, you must use the free_fn replacement that you provided.

Note also that if you are going to call this function, you should do so before any call to any Libevent function that does allocation. Otherwise, those funtions will allocate their memory using malloc(), but then later free it using your provided free_fn.

Parameters

  malloc_fn | A replacement for malloc.
  realloc_fn | A replacement for realloc
  free_fn | A replacement for free.