Predefined Constants

Flags passed to create a loop:

Ev::FLAG_AUTO

The default flags value

Ev::FLAG_NOENV

If this flag used(or the program runs setuid or setgid),
libev
won't look at the environment variable
LIBEV_FLAGS
. Otherwise(by default),
LIBEV_FLAGS
will override the flags completely if it is found. Useful for
performance tests and searching for bugs.

Ev::FLAG_FORKCHECK

Makes libev check for a fork in each iteration, instead of calling
EvLoop::fork()
manually. This works by calling
getpid()
on every iteration of the loop, and thus this might slow down the
event loop with lots of loop iterations, but usually is not
noticeable. This flag setting cannot be overridden or specified in the
LIBEV_FLAGS
environment variable.

Ev::FLAG_NOINOTIFY

When this flag is specified,
libev
won't attempt to use the
inotify
API for its
» ev_stat
watchers. The flag can be useful to conserve inotify file descriptors,
as otherwise each loop using
ev_stat
watchers consumes one
inotify
handle.

Ev::FLAG_SIGNALFD

When this flag is specified,
libev
will attempt to use the
signalfd
API for its
» ev_signal
(and
» ev_child
) watchers. This API delivers signals synchronously, which makes it
both faster and might make it possible to get the queued signal data.
It can also simplify signal handling with threads, as long as signals
are properly blocked in threads.
Signalfd
will not be used by default.

Ev::FLAG_NOSIGMASK

When this flag is specified,
libev
will avoid to modify the signal mask. Specifically, this means having
to make sure signals are unblocked before receiving them.

This behaviour is useful for custom signal handling, or handling
signals only in specific threads.

Means that event loop will look for new events, will handle those
events and any already outstanding ones, but will not wait and block
the process in case there are no events and will return after one
iteration of the loop. This is sometimes useful to poll and handle new
events while doing lengthy calculations, to keep the program
responsive.

Ev::RUN_ONCE

Means that event loop will look for new events (waiting if necessary)
and will handle those and any already outstanding ones. It will block
the process until at least one new event arrives (which could be an
event internal to libev itself, so there is no guarantee that a
user-registered callback will be called), and will return after one
iteration of the loop.

All
EvPrepare
watchers are invoked just before
Ev::run()
starts. Thus,
EvPrepare
watchers are the last watchers invoked before the event loop sleeps or
polls for new events.

Ev::CHECK

All
EvCheck
watchers are queued just after
Ev::run()
has gathered the new events, but before it queues any callbacks for
any received events. Thus,
EvCheck
watchers will be invoked before any other watchers of the same or
lower priority within an event loop iteration.

Not ever sent(or otherwise used) by
libev
itself, but can be freely used by
libev
users to signal watchers (e.g. via
EvWatcher::feed()
).

Ev::ERROR

An unspecified error has occurred, the watcher has been stopped. This
might happen because the watcher could not be properly started because
libev
ran out of memory, a file descriptor was found to be closed or any
other problem.
Libev
considers these application bugs. See also
» ANATOMY
OF A WATCHER

Backend flags:

Ev::BACKEND_SELECT

select(2) backend

Ev::BACKEND_POLL

poll(2) backend

Ev::BACKEND_EPOLL

Linux-specific
epoll(7)
backend for both pre- and post-2.6.9 kernels

Ev::BACKEND_KQUEUE

kqueue
backend used on most BSD systems.
EvEmbed
watcher could be used to embed one loop(with kqueue backend) into
another. For instance, one can try to create an event loop with
kqueue
backend and use it for sockets only.

Ev::BACKEND_DEVPOLL

Solaris 8 backend. This is not implemented yet.

Ev::BACKEND_PORT

Solaris 10 event port mechanism with a good scaling.

Ev::BACKEND_ALL

Try all backends(even currupted ones). It's not recommended to use it
explicitly. Bitwise operators should be applied here(e.g.
Ev::BACKEND_ALL
& ~
Ev::BACKEND_KQUEUE
) Use
Ev::recommendedBackends()
, or don't specify any backends at all.

Ev::BACKEND_MASK

Not a backend, but a mask to select all backend bits from
flags
value to mask out any backends(e.g. when modifying the
LIBEV_FLAGS
environment variable).