libev中文手册

libev 地址：http://software.schmorp.de/pkg/libev.html

手册英文地址 ：http://doc.dvgu.ru/devel/ev.html

因为开始要学习和研究libev，所以免不了要学习手册。遂准备将手册翻译整理。

希望有兴趣的朋友一起来参与，翻译版权为互联网共享，但我会保留各位作者（原稿、修改）大名。

大家可按照自己学习和感兴趣的模块顺序来翻译，由我来汇总。

因为白天工作的缘故，我将主要晚上来整理，大家可直接发我邮箱hiproz#gmail.com。

邮件标题为段落层次序号和段落名，比如 2.1.EXAMPLE PROGRAM 
邮件内容顶端写明所翻译内容的段落层次，方便我集成。

内容提供人最好留下自己希望显示在页面上的网名和网址链接。如果没有我将以cnblogs 帐号和邮件帐号为准。 

录用和更新将按照投稿的时间决定，重复翻译的将忽略，如果觉得翻译不妥的地方，请以修订的方式发出邮件，或者留言，勿重复通篇翻译。

欢迎各位libever 踊跃参与、讨论分享！！！！ 

翻译贡献者：

 IntelIOT

 

 

NAME

libev - a high performance full-featured event loop written in C 

Titlelibev -- 一个基于C语言的高性能全功能事件循环处理框架。

 

SYNOPSIS

 #include <ev.h>

 

EXAMPLE PROGRAM

 // a single header file is required #include <ev.h>
 // every watcher type has its own typedef'd struct // with the name ev_<type> ev_io stdin_watcher; ev_timer timeout_watcher;
 // all watcher callbacks have a similar signature // this callback is called when data is readable on stdin static void stdin_cb (EV_P_ struct ev_io *w, int revents) { puts ("stdin ready"); // for one-shot events, one must manually stop the watcher // with its corresponding stop function. ev_io_stop (EV_A_ w);
 // this causes all nested ev_loop's to stop iterating ev_unloop (EV_A_ EVUNLOOP_ALL); }
 // another callback, this time for a time-out static void timeout_cb (EV_P_ struct ev_timer *w, int revents) { puts ("timeout"); // this causes the innermost ev_loop to stop iterating ev_unloop (EV_A_ EVUNLOOP_ONE); }
 int main (void) { // use the default event loop unless you have special needs struct ev_loop *loop = ev_default_loop (0);
 // initialise an io watcher, then start it // this one will watch for stdin to become readable ev_io_init (&stdin_watcher, stdin_cb, /*STDIN_FILENO*/ 0, EV_READ); ev_io_start (loop, &stdin_watcher);
 // initialise a timer watcher, then start it // simple non-repeating 5.5 second timeout ev_timer_init (&timeout_watcher, timeout_cb, 5.5, 0.); ev_timer_start (loop, &timeout_watcher);
 // now wait for events to arrive ev_loop (loop, 0);
 // unloop was called, so exit return 0; }

 

// a single header file is required 
#include <ev.h>
// every watcher type has its own typedef'd struct 
// with the name ev_<type> ev_io stdin_watcher; ev_timer timeout_watcher;
// all watcher callbacks have a similar signature 
// this callback is called when data is readable on stdin 
static void stdin_cb (EV_P_ struct ev_io *w, int revents) 
{ 
puts ("stdin ready"); 
// for one-shot events, one must manually stop the watcher 
// with its corresponding stop function. ev_io_stop (EV_A_ w);
 // this causes all nested ev_loop's to stop iterating ev_unloop (EV_A_ EVUNLOOP_ALL); 
}

// another callback, this time for a time-out static void timeout_cb (EV_P_ struct ev_timer *w, int revents) { puts ("timeout"); 
// this causes the innermost ev_loop to stop iterating ev_unloop (EV_A_ EVUNLOOP_ONE); 
}

int main (void) { 
// use the default event loop unless you have special needs struct ev_loop *loop = ev_default_loop (0);
// initialise an io watcher, then start it 
// this one will watch for stdin to become readable ev_io_init (&stdin_watcher, stdin_cb, /*STDIN_FILENO*/ 0, EV_READ); 
ev_io_start (loop, &stdin_watcher);
// initialise a timer watcher, then start it 
// simple non-repeating 5.5 second timeout ev_timer_init (&timeout_watcher, timeout_cb, 5.5, 0.); ev_timer_start (loop, &timeout_watcher);
// now wait for events to arrive ev_loop (loop, 0);
// unloop was called, so exit return 0; 
}

 

DESCRIPTION

The newest version of this document is also available as an html-formattedweb page you might find easier to navigate when reading it for the firsttime: http://pod.tst.eu/http://cvs.schmorp.de/libev/ev.pod.

Libev is an event loop: you register interest in certain events (such as afile descriptor being readable or a timeout occurring), and it will managethese event sources and provide your program with events.

To do this, it must take more or less complete control over your process(or thread) by executing the event loop handler, and will thencommunicate events via a callback mechanism.

You register interest in certain events by registering so-called eventwatchers, which are relatively small C structures you initialise with thedetails of the event, and then hand it over to libev by starting thewatcher.

 

FEATURES

Libev supports select, poll, the Linux-specific epoll, theBSD-specific kqueue and the Solaris-specific event port mechanismsfor file descriptor events (ev_io), the Linux inotify interface(for ev_stat), relative timers (ev_timer), absolute timerswith customised rescheduling (ev_periodic), synchronous signals(ev_signal), process status change events (ev_child), and eventwatchers dealing with the event loop mechanism itself (ev_idle,ev_embed, ev_prepare and ev_check watchers) as well asfile watchers (ev_stat) and even limited support for fork events(ev_fork).

It also is quite fast (see thisbenchmark comparing it to libeventfor example).

 

CONVENTIONS

Libev is very configurable. In this manual the default (and most common)configuration will be described, which supports multiple event loops. Formore info about various configuration options please have a look atEMBED section in this manual. If libev was configured without supportfor multiple event loops, then all functions taking an initial argument ofname loop (which is always of type struct ev_loop *) will not havethis argument.

 

TIME REPRESENTATION

Libev represents time as a single floating point number, representing the(fractional) number of seconds since the (POSIX) epoch (somewhere nearthe beginning of 1970, details are complicated, don't ask). This type iscalled ev_tstamp, which is what you should use too. It usually aliasesto the double type in C, and when you need to do any calculations onit, you should treat it as some floatingpoint value. Unlike the namecomponent stamp might indicate, it is also used for time differencesthroughout libev.

 

ERROR HANDLING

Libev knows three classes of errors: operating system errors, usage errorsand internal errors (bugs).

When libev catches an operating system error it cannot handle (for examplea syscall indicating a condition libev cannot fix), it calls the callbackset via ev_set_syserr_cb, which is supposed to fix the problem orabort. The default is to print a diagnostic message and to call abort().

When libev detects a usage error such as a negative timer interval, thenit will print a diagnostic message and abort (via the assert mechanism,so NDEBUG will disable this checking): these are programming errors inthe libev caller and need to be fixed there.

Libev also has a few internal error-checking assertions, and also hasextensive consistency checking code. These do not trigger under normalcircumstances, as they indicate either a bug in libev or worse.

 

GLOBAL FUNCTIONS

These functions can be called anytime, even before initialising thelibrary in any way.  

Title这些全局函数可在任何时候任何方式调用，甚至在初始化库之前。

 ev_tstamp ev_time ()

Returns the current time as libev would use it. Please note that theev_now function is usually faster and also often returns the timestampyou actually want to know.

ev_sleep (ev_tstamp interval)

Sleep for the given interval: The current thread will be blocked untileither it is interrupted or the given time interval has passed. Basicallythis is a subsecond-resolution sleep ().

int ev_version_major ()
int ev_version_minor ()

You can find out the major and minor ABI version numbers of the libraryyou linked against by calling the functions ev_version_major andev_version_minor. If you want, you can compare against the globalsymbols EV_VERSION_MAJOR and EV_VERSION_MINOR, which specify theversion of the library your program was compiled against.

These version numbers refer to the ABI version of the library, not therelease version.

Usually, it's a good idea to terminate if the major versions mismatch,as this indicates an incompatible change. Minor versions are usuallycompatible to older versions, so a larger minor version alone is usuallynot a problem.

Example: Make sure we haven't accidentally been linked against the wrongversion.

 assert (("libev version mismatch", ev_version_major () == EV_VERSION_MAJOR && ev_version_minor () >= EV_VERSION_MINOR));
unsigned int ev_supported_backends ()

Return the set of all backends (i.e. their corresponding EV_BACKEND_*value) compiled into this binary of libev (independent of theiravailability on the system you are running on). See ev_default_loop fora description of the set values.

Example: make sure we have the epoll method, because yeah this is cool anda must have and can we have a torrent of it please!!!11

 assert (("sorry, no epoll, no sex", ev_supported_backends () & EVBACKEND_EPOLL));
unsigned int ev_recommended_backends ()

Return the set of all backends compiled into this binary of libev and alsorecommended for this platform. This set is often smaller than the onereturned by ev_supported_backends, as for example kqueue is broken onmost BSDs and will not be autodetected unless you explicitly request it(assuming you know what you are doing). This is the set of backends thatlibev will probe for if you specify no backends explicitly.

unsigned int ev_embeddable_backends ()

Returns the set of backends that are embeddable in other event loops. Thisis the theoretical, all-platform, value. To find which backendsmight be supported on the current system, you would need to look atev_embeddable_backends () & ev_supported_backends (), likewise forrecommended ones.

See the description of ev_embed watchers for more info.

ev_set_allocator (void *(*cb)(void *ptr, long size))

Sets the allocation function to use (the prototype is similar - thesemantics are identical to the realloc C89/SuS/POSIX function). It isused to allocate and free memory (no surprises here). If it returns zerowhen memory needs to be allocated (size != 0), the library might abortor take some potentially destructive action.

Since some systems (at least OpenBSD and Darwin) fail to implementcorrect realloc semantics, libev will use a wrapper around the systemrealloc and free functions by default.

You could override this function in high-availability programs to, say,free some memory if it cannot allocate memory, to use a special allocator,or even to sleep a while and retry until some memory is available.

Example: Replace the libev allocator with one that waits a bit and thenretries (example requires a standards-compliant realloc).

 static void * persistent_realloc (void *ptr, size_t size) { for (;;) { void *newptr = realloc (ptr, size);
 if (newptr) return newptr;
 sleep (60); } }
 ... ev_set_allocator (persistent_realloc);
ev_set_syserr_cb (void (*cb)(const char *msg));

Set the callback function to call on a retryable syscall error (suchas failed select, poll, epoll_wait). The message is a printable stringindicating the system call or subsystem causing the problem. If thiscallback is set, then libev will expect it to remedy the sitution, nomatter what, when it returns. That is, libev will generally retry therequested operation, or, if the condition doesn't go away, do bad stuff(such as abort).

Example: This is basically the same thing that libev does internally, too.

 static void fatal_error (const char *msg) { perror (msg); abort (); }
 ... ev_set_syserr_cb (fatal_error);

 

FUNCTIONS CONTROLLING THE EVENT LOOP

An event loop is described by a struct ev_loop *. The library knows twotypes of such loops, the default loop, which supports signals and childevents, and dynamically created loops which do not. 

Titleev_loop* 用来表示一个时间循环。系统支持2种循环对象，支持信号和子事件的default loop 和dynamically loop。

  struct ev_loop *ev_default_loop (unsigned int flags)

This will initialise the default event loop if it hasn't been initialisedyet and return it. If the default loop could not be initialised, returnsfalse. If it already was initialised it simply returns it (and ignores theflags. If that is troubling you, check ev_backend () afterwards).

If you don't know what event loop to use, use the one returned from thisfunction.

Note that this function is not thread-safe, so if you want to use itfrom multiple threads, you have to lock (note also that this is unlikely,as loops cannot bes hared easily between threads anyway).

The default loop is the only loop that can handle ev_signal andev_child watchers, and to do this, it always registers a handlerfor SIGCHLD. If this is a problem for your app you can eithercreate a dynamic loop with ev_loop_new that doesn't do that, or youcan simply overwrite the SIGCHLD signal handler after callingev_default_init.

The flags argument can be used to specify special behaviour or specificbackends to use, and is usually specified as 0 (or EVFLAG_AUTO).

The following flags are supported:

 

Title这个函数将初始化default event loop 对象并得到事件对象。如果 default loop 不能被初始化，函数将会返回 false。如果对象已经初始化了，直接返回对象（同时忽略 flags。如果不太清楚，可以参看后面的 ev_backend() ）。
如果你不太清楚该使用哪种类型的event loop，那么建议你使用该类型。
切记，此函数不是线程安全的，所以如果你想使用多线程，你需要去加锁（同时需要注意这样做似乎有些不可能，因为循环很难做到相互独立）。
default loop 是唯一能处理 ev_signal 和ev_child watcher的。为了处理，需要注册SIGCHLD函数。如果你觉得这样有些困难，你可以使用 ev_loop_new，就不需要注册了。或者在调用ev_default_init 后 直接重入 SIGCHLD 处理函数.
函数参数又来指明特定的行为或者backend。默认一般是0（EVFLAG_AUTO）。
当前支持如下的标志：

 

EVFLAG_AUTO

The default flags value. Use this if you have no clue (it's the rightthing, believe me).

 

Title当你不知道该如何设置此参数时，可以使用此标识。
 

 

EVFLAG_NOENV

If this flag bit is ored into the flag value (or the program runs setuidor setgid) then libev will not look at the environment variableLIBEV_FLAGS. Otherwise (the default), this environment variable willoverride the flags completely if it is found in the environment. This isuseful to try out specific backends to test their performance, or to workaround bugs.

 

Title当此标识被 | 进flags 时(或者在程序中执行 setuid 或 setgid函数)，libev将忽略环境变量LIVEV_FLAGS。否则libev默认将会集成此标识。这种用环境变量配置的的方式（不用修改代码），一般在性能调优或者bug测试时很有用。
 

 

EVFLAG_FORKCHECK

Instead of calling ev_default_fork or ev_loop_fork manually aftera fork, you can also make libev check for a fork in each iteration byenabling this flag.

This works by calling getpid () on every iteration of the loop,and thus this might slow down your event loop if you do a lot of loopiterations and little real work, but is usually not noticeable (on myGNU/Linux system for example, getpid is actually a simple 5-insn sequencewithout a syscall and thus very fast, but my GNU/Linux system also haspthread_atfork which is even faster).

The big advantage of this flag is that you can forget about fork (andforget about forgetting to tell libev about forking) when you use thisflag.

This flag setting cannot be overriden or specified in the LIBEV_FLAGSenvironment variable.

EVBACKEND_SELECT (value 1, portable select backend)

This is your standard select(2) backend. Not completely standard, aslibev tries to roll its own fd_set with no limits on the number of fds,but if that fails, expect a fairly low limit on the number of fds whenusing this backend. It doesn't scale too well (O(highest_fd)), but itsusually the fastest backend for a low number of (low-numbered :) fds.

To get good performance out of this backend you need a high amount ofparallelity (most of the file descriptors should be busy). If you arewriting a server, you should accept () in a loop to accept as manyconnections as possible during one iteration. You might also want to havea look at ev_set_io_collect_interval () to increase the amount ofreadiness notifications you get per iteration.

EVBACKEND_POLL (value 2, poll backend, available everywhere except on windows)

And this is your standard poll(2) backend. It's more complicatedthan select, but handles sparse fds better and has no artificiallimit on the number of fds you can use (except it will slow downconsiderably with a lot of inactive fds). It scales similarly to select,i.e. O(total_fds). See the entry for EVBACKEND_SELECT, above, forperformance tips.

EVBACKEND_EPOLL (value 4, Linux)

For few fds, this backend is a bit little slower than poll and select,but it scales phenomenally better. While poll and select usually scalelike O(total_fds) where n is the total number of fds (or the highest fd),epoll scales either O(1) or O(active_fds). The epoll design has a numberof shortcomings, such as silently dropping events in some hard-to-detectcases and requiring a syscall per fd change, no fork support and badsupport for dup.

While stopping, setting and starting an I/O watcher in the same iterationwill result in some caching, there is still a syscall per such incident(because the fd could point to a different file description now), so itsbest to avoid that. Also, dup ()'ed file descriptors might not workvery well if you register events for both fds.

Please note that epoll sometimes generates spurious notifications, so youneed to use non-blocking I/O or other means to avoid blocking when no data(or space) is available.

Best performance from this backend is achieved by not unregistering allwatchers for a file descriptor until it has been closed, if possible, i.e.keep at least one watcher active per fd at all times.

While nominally embeddeble in other event loops, this feature is broken inall kernel versions tested so far.

EVBACKEND_KQUEUE (value 8, most BSD clones)

Kqueue deserves special mention, as at the time of this writing, itwas broken on all BSDs except NetBSD (usually it doesn't work reliablywith anything but sockets and pipes, except on Darwin, where of courseit's completely useless). For this reason it's not being ``autodetected''unless you explicitly specify it explicitly in the flags (i.e. usingEVBACKEND_KQUEUE) or libev was compiled on a known-to-be-good (-enough)system like NetBSD.

You still can embed kqueue into a normal poll or select backend and use itonly for sockets (after having made sure that sockets work with kqueue onthe target platform). See ev_embed watchers for more info.

It scales in the same way as the epoll backend, but the interface to thekernel is more efficient (which says nothing about its actual speed, ofcourse). While stopping, setting and starting an I/O watcher does nevercause an extra syscall as with EVBACKEND_EPOLL, it still adds up totwo event changes per incident, support for fork () is very bad and itdrops fds silently in similarly hard-to-detect cases.

This backend usually performs well under most conditions.

While nominally embeddable in other event loops, this doesn't workeverywhere, so you might need to test for this. And since it is brokenalmost everywhere, you should only use it when you have a lot of sockets(for which it usually works), by embedding it into another event loop(e.g. EVBACKEND_SELECT or EVBACKEND_POLL) and using it only forsockets.

EVBACKEND_DEVPOLL (value 16, Solaris 8)

This is not implemented yet (and might never be, unless you send me animplementation). According to reports, /dev/poll only supports socketsand is not embeddable, which would limit the usefulness of this backendimmensely.

EVBACKEND_PORT (value 32, Solaris 10)

This uses the Solaris 10 event port mechanism. As with everything on Solaris,it's really slow, but it still scales very well (O(active_fds)).

Please note that solaris event ports can deliver a lot of spuriousnotifications, so you need to use non-blocking I/O or other means to avoidblocking when no data (or space) is available.

While this backend scales well, it requires one system call per activefile descriptor per loop iteration. For small and medium numbers of filedescriptors a ``slow'' EVBACKEND_SELECT or EVBACKEND_POLL backendmight perform better.

On the positive side, ignoring the spurious readiness notifications, thisbackend actually performed to specification in all tests and is fullyembeddable, which is a rare feat among the OS-specific backends.

EVBACKEND_ALL

Try all backends (even potentially broken ones that wouldn't be triedwith EVFLAG_AUTO). Since this is a mask, you can do stuff such asEVBACKEND_ALL & ~EVBACKEND_KQUEUE.

It is definitely not recommended to use this flag.

If one or more of these are ored into the flags value, then only thesebackends will be tried (in the reverse order as listed here). If none arespecified, all backends in ev_recommended_backends () will be tried.

The most typical usage is like this:

 if (!ev_default_loop (0)) fatal ("could not initialise libev, bad $LIBEV_FLAGS in environment?");

Restrict libev to the select and poll backends, and do not allowenvironment settings to be taken into account:

 ev_default_loop (EVBACKEND_POLL | EVBACKEND_SELECT | EVFLAG_NOENV);

Use whatever libev has to offer, but make sure that kqueue is used ifavailable (warning, breaks stuff, best use only with your own privateevent loop and only if you know the OS supports your types of fds):

 ev_default_loop (ev_recommended_backends () | EVBACKEND_KQUEUE);
struct ev_loop *ev_loop_new (unsigned int flags)

Similar to ev_default_loop, but always creates a new event loop that isalways distinct from the default loop. Unlike the default loop, it cannothandle signal and child watchers, and attempts to do so will be greeted byundefined behaviour (or a failed assertion if assertions are enabled).

Note that this function is thread-safe, and the recommended way to uselibev with threads is indeed to create one loop per thread, and using thedefault loop in the ``main'' or ``initial'' thread.

Example: Try to create a event loop that uses epoll and nothing else.

 struct ev_loop *epoller = ev_loop_new (EVBACKEND_EPOLL | EVFLAG_NOENV); if (!epoller) fatal ("no epoll found here, maybe it hides under your chair");
ev_default_destroy ()

Destroys the default loop again (frees all memory and kernel stateetc.). None of the active event watchers will be stopped in the normalsense, so e.g. ev_is_active might still return true. It is yourresponsibility to either stop all watchers cleanly yoursef beforecalling this function, or cope with the fact afterwards (which is usuallythe easiest thing, you can just ignore the watchers and/or free () themfor example).

Note that certain global state, such as signal state, will not be freed bythis function, and related watchers (such as signal and child watchers)would need to be stopped manually.

In general it is not advisable to call this function except in therare occasion where you really need to free e.g. the signal handlingpipe fds. If you need dynamically allocated loops it is better to useev_loop_new and ev_loop_destroy).

ev_loop_destroy (loop)

Like ev_default_destroy, but destroys an event loop created by anearlier call to ev_loop_new.

ev_default_fork ()

This function sets a flag that causes subsequent ev_loop iterationsto reinitialise the kernel state for backends that have one. Despite thename, you can call it anytime, but it makes most sense after forking, inthe child process (or both child and parent, but that again makes littlesense). You must call it in the child before using any of the libevfunctions, and it will only take effect at the next ev_loop iteration.

On the other hand, you only need to call this function in the childprocess if and only if you want to use the event library in the child. Ifyou just fork+exec, you don't have to call it at all.

The function itself is quite fast and it's usually not a problem to callit just in case after a fork. To make this easy, the function will fit inquite nicely into a call to pthread_atfork:

 pthread_atfork (0, 0, ev_default_fork);
 
   
 
   
 
    ev_loop_fork (loop) 
   
 
   
 
    
Like ev_default_fork, but acts on an event loop created byev_loop_new. Yes, you have to call this on every allocated event loopafter fork, and how you do this is entirely your own problem.
 
   
 
   
 
    int ev_is_default_loop (loop) 
   
 
   
 
    
Returns true when the given loop actually is the default loop, false otherwise.
 
   
 
   
 
    unsigned int ev_loop_count (loop) 
   
 
   
 
    
Returns the count of loop iterations for the loop, which is identical tothe number of times libev did poll for new events. It starts at 0 andhappily wraps around with enough iterations.
 
   
 
   
 
    
This value can sometimes be useful as a generation counter of sorts (it``ticks'' the number of loop iterations), as it roughly corresponds withev_prepare and ev_check calls.
 
   
 
   
 
    unsigned int ev_backend (loop) 
   
 
   
 
    
Returns one of the EVBACKEND_* flags indicating the event backend inuse.
 
   
 
   
 
    ev_tstamp ev_now (loop) 
   
 
   
 
    
Returns the current ``event loop time'', which is the time the event loopreceived events and started processing them. This timestamp does notchange as long as callbacks are being processed, and this is also the basetime used for relative timers. You can treat it as the timestamp of theevent occurring (or more correctly, libev finding out about it).
 
   
 
   
 
    ev_loop (loop, int flags) 
   
 
   
 
    
Finally, this is it, the event handler. This function usually is calledafter you initialised all your watchers and you want to start handlingevents.
 
   
 
   
 
    
If the flags argument is specified as 0, it will not return untileither no event watchers are active anymore or ev_unloop was called.
 
   
 
   
 
    
Please note that an explicit ev_unloop is usually better thanrelying on all watchers to be stopped when deciding when a program hasfinished (especially in interactive programs), but having a program thatautomatically loops as long as it has to and no longer by virtue ofrelying on its watchers stopping correctly is a thing of beauty.
 
   
 
   
 
    
A flags value of EVLOOP_NONBLOCK will look for new events, will handlethose events and any outstanding ones, but will not block your process incase there are no events and will return after one iteration of the loop.
 
   
 
   
 
    
A flags value of EVLOOP_ONESHOT will look for new events (waiting ifneccessary) and will handle those and any outstanding ones. It will blockyour process until at least one new event arrives, and will return afterone iteration of the loop. This is useful if you are waiting for someexternal event in conjunction with something not expressible using otherlibev watchers. However, a pair of ev_prepare/ev_check watchers isusually a better approach for this kind of thing.
 
   
 
   
 
    
Here are the gory details of what ev_loop does:
 
   
 
   
 
    
 - Before the first iteration, call any pending watchers. * If EVFLAG_FORKCHECK was used, check for a fork. - If a fork was detected, queue and call all fork watchers. - Queue and call all prepare watchers. - If we have been forked, recreate the kernel state. - Update the kernel state with all outstanding changes. - Update the "event loop time". - Calculate for how long to sleep or block, if at all (active idle watchers, EVLOOP_NONBLOCK or not having any active watchers at all will result in not sleeping). - Sleep if the I/O and timer collect interval say so. - Block the process, waiting for any events. - Queue all outstanding I/O (fd) events. - Update the "event loop time" and do time jump handling. - Queue all outstanding timers. - Queue all outstanding periodics. - If no events are pending now, queue all idle watchers. - Queue all check watchers. - Call all queued watchers in reverse order (i.e. check watchers first). Signals and child watchers are implemented as I/O watchers, and will be handled here by queueing them when their watcher gets executed. - If ev_unloop has been called, or EVLOOP_ONESHOT or EVLOOP_NONBLOCK were used, or there are no active watchers, return, otherwise continue with step *.
 
   
 
   
 
    
Example: Queue some jobs and then loop until no events are outstandinganymore.
 
   
 
   
 
    
 ... queue jobs here, make sure they register event watchers as long ... as they still have work to do (even an idle watcher will do..) ev_loop (my_loop, 0); ... jobs done. yeah!
 
   
 
   
 
    ev_unloop (loop, how) 
   
 
   
 
    
Can be used to make a call to ev_loop return early (but only after ithas processed all outstanding events). The how argument must be eitherEVUNLOOP_ONE, which will make the innermost ev_loop call return, orEVUNLOOP_ALL, which will make all nested ev_loop calls return.
 
   
 
   
 
    
This ``unloop state'' will be cleared when entering ev_loop again.
 
   
 
   
 
    ev_ref (loop) 
   
 
   
 
    ev_unref (loop) 
   
 
   
 
    
Ref/unref can be used to add or remove a reference count on the eventloop: Every watcher keeps one reference, and as long as the referencecount is nonzero, ev_loop will not return on its own. If you havea watcher you never unregister that should not keep ev_loop fromreturning, ev_unref() after starting, and ev_ref() before stopping it. Forexample, libev itself uses this for its internal signal pipe: It is notvisible to the libev user and should not keep ev_loop from exiting ifno event watchers registered by it are active. It is also an excellentway to do this for generic recurring timers or from within third-partylibraries. Just remember to unref after start and ref before stop(but only if the watcher wasn't active before, or was active before,respectively).
 
   
 
   
 
    
Example: Create a signal watcher, but keep it from keeping ev_looprunning when nothing else is active.
 
   
 
   
 
    
 struct ev_signal exitsig; ev_signal_init (&exitsig, sig_cb, SIGINT); ev_signal_start (loop, &exitsig); evf_unref (loop);
 
   
 
   
 
    
Example: For some weird reason, unregister the above signal handler again.
 
   
 
   
 
    
 ev_ref (loop); ev_signal_stop (loop, &exitsig);
 
   
 
   
 
    ev_set_io_collect_interval (loop, ev_tstamp interval) 
   
 
   
 
    ev_set_timeout_collect_interval (loop, ev_tstamp interval) 
   
 
   
 
    
These advanced functions influence the time that libev will spend waitingfor events. Both are by default 0, meaning that libev will try toinvoke timer/periodic callbacks and I/O callbacks with minimum latency.
 
   
 
   
 
    
Setting these to a higher value (the intervalmust be >= 0)allows libev to delay invocation of I/O and timer/periodic callbacks toincrease efficiency of loop iterations.
 
   
 
   
 
    
The background is that sometimes your program runs just fast enough tohandle one (or very few) event(s) per loop iteration. While this makesthe program responsive, it also wastes a lot of CPU time to poll for newevents, especially with backends like select () which have a highoverhead for the actual polling but can deliver many events at once.
 
   
 
   
 
    
By setting a higher io collect interval you allow libev to spend moretime collecting I/O events, so you can handle more events per iteration,at the cost of increasing latency. Timeouts (both ev_periodic andev_timer) will be not affected. Setting this to a non-null value willintroduce an additional ev_sleep () call into most loop iterations.
 
   
 
   
 
    
Likewise, by setting a higher timeout collect interval you allow libevto spend more time collecting timeouts, at the expense of increasedlatency (the watcher callback will be called later). ev_io watcherswill not be affected. Setting this to a non-null value will not introduceany overhead in libev.
 
   
 
   
 
    
Many (busy) programs can usually benefit by setting the io collectinterval to a value near 0.1 or so, which is often enough forinteractive servers (of course not for games), likewise for timeouts. Itusually doesn't make much sense to set it to a lower value than 0.01,as this approsaches the timing granularity of most systems.
 
   
 
   
 
    ev_loop_verify (loop) 
   
 
   
 
    
This function only does something when EV_VERIFY support has beencompiled in. It tries to go through all internal structures and checksthem for validity. If anything is found to be inconsistent, it will printan error message to standard error and call abort ().
 
   
 
   
 
    
This can be used to catch bugs inside libev itself: under normalcircumstances, this function will never abort as of course libev keeps itsdata structures consistent.
 
   
 
  
 
  
 
 
  
 
  
ANATOMY OF A WATCHER
 
  
A watcher is a structure that you create and register to record yourinterest in some event. For instance, if you want to wait for STDIN tobecome readable, you would create an ev_io watcher for that:
 
  
 static void my_cb (struct ev_loop *loop, struct ev_io *w, int revents) { ev_io_stop (w); ev_unloop (loop, EVUNLOOP_ALL); }
 
  
 struct ev_loop *loop = ev_default_loop (0); struct ev_io stdin_watcher; ev_init (&stdin_watcher, my_cb); ev_io_set (&stdin_watcher, STDIN_FILENO, EV_READ); ev_io_start (loop, &stdin_watcher); ev_loop (loop, 0);
 
  
As you can see, you are responsible for allocating the memory for yourwatcher structures (and it is usually a bad idea to do this on the stack,although this can sometimes be quite valid).
 
  
Each watcher structure must be initialised by a call to ev_init(watcher *, callback), which expects a callback to be provided. Thiscallback gets invoked each time the event occurs (or, in the case of iowatchers, each time the event loop detects that the file descriptor givenis readable and/or writable).
 
  
Each watcher type has its own ev_<type>_set (watcher *, ...) macrowith arguments specific to this watcher type. There is also a macroto combine initialisation and setting in one call: ev_<type>_init(watcher *, callback, ...).
 
  
To make the watcher actually watch out for events, you have to start itwith a watcher-specific start function (ev_<type>_start (loop, watcher*)), and you can stop watching for events at any time by calling thecorresponding stop function (ev_<type>_stop (loop, watcher *).
 
  
As long as your watcher is active (has been started but not stopped) youmust not touch the values stored in it. Most specifically you must neverreinitialise it or call its set macro.
 
  
Each and every callback receives the event loop pointer as first, theregistered watcher structure as second, and a bitset of received events asthird argument.
 
  
The received events usually include a single bit per event type received(you can receive multiple events at the same time). The possible bit masksare:
 
  
 
   
 
    EV_READ 
   
 
   
 
    EV_WRITE 
   
 
   
 
    
The file descriptor in the ev_io watcher has become readable and/orwritable.
 
   
 
   
 
    EV_TIMEOUT 
   
 
   
 
    
The ev_timer watcher has timed out.
 
   
 
   
 
    EV_PERIODIC 
   
 
   
 
    
The ev_periodic watcher has timed out.
 
   
 
   
 
    EV_SIGNAL 
   
 
   
 
    
The signal specified in the ev_signal watcher has been received by a thread.
 
   
 
   
 
    EV_CHILD 
   
 
   
 
    
The pid specified in the ev_child watcher has received a status change.
 
   
 
   
 
    EV_STAT 
   
 
   
 
    
The path specified in the ev_stat watcher changed its attributes somehow.
 
   
 
   
 
    EV_IDLE 
   
 
   
 
    
The ev_idle watcher has determined that you have nothing better to do.
 
   
 
   
 
    EV_PREPARE 
   
 
   
 
    EV_CHECK 
   
 
   
 
    
All ev_prepare watchers are invoked just beforeev_loop startsto gather new events, and all ev_check watchers are invoked just afterev_loop has gathered them, but before it invokes any callbacks for anyreceived events. Callbacks of both watcher types can start and stop asmany watchers as they want, and all of them will be taken into account(for example, a ev_prepare watcher might start an idle watcher to keepev_loop from blocking).
 
   
 
   
 
    EV_EMBED 
   
 
   
 
    
The embedded event loop specified in the ev_embed watcher needs attention.
 
   
 
   
 
    EV_FORK 
   
 
   
 
    
The event loop has been resumed in the child process after fork (seeev_fork).
 
   
 
   
 
    EV_ASYNC 
   
 
   
 
    
The given async watcher has been asynchronously notified (see ev_async).
 
   
 
   
 
    EV_ERROR 
   
 
   
 
    
An unspecified error has occured, the watcher has been stopped. This mighthappen because the watcher could not be properly started because libevran out of memory, a file descriptor was found to be closed or any otherproblem. You best act on it by reporting the problem and somehow copingwith the watcher being stopped.
 
   
 
   
 
    
Libev will usually signal a few ``dummy'' events together with an error,for example it might indicate that a fd is readable or writable, and ifyour callbacks is well-written it can just attempt the operation and copewith the error from read() or write(). This will not work in multithreadedprograms, though, so beware.
 
   
 
  
 
  
 
 
  
GENERIC WATCHER FUNCTIONS
 
  
In the following description, TYPE stands for the watcher type,e.g. timer for ev_timer watchers and io for ev_io watchers.
 
  
 
   
 
    ev_init (ev_TYPE *watcher, callback) 
   
 
   
 
    
This macro initialises the generic portion of a watcher. The contentsof the watcher object can be arbitrary (so malloc will do). Onlythe generic parts of the watcher are initialised, you need to callthe type-specific ev_TYPE_set macro afterwards to initialise thetype-specific parts. For each type there is also a ev_TYPE_init macrowhich rolls both calls into one.
 
   
 
   
 
    
You can reinitialise a watcher at any time as long as it has been stopped(or never started) and there are no pending events outstanding.
 
   
 
   
 
    
The callback is always of type void (*)(ev_loop *loop, ev_TYPE *watcher,int revents).
 
   
 
   
 
    ev_TYPE_set (ev_TYPE *, [args]) 
   
 
   
 
    
This macro initialises the type-specific parts of a watcher. You need tocall ev_init at least once before you call this macro, but you cancall ev_TYPE_set any number of times. You must not, however, call thismacro on a watcher that is active (it can be pending, however, which is adifference to the ev_init macro).
 
   
 
   
 
    
Although some watcher types do not have type-specific arguments(e.g. ev_prepare) you still need to call its set macro.
 
   
 
   
 
    ev_TYPE_init (ev_TYPE *watcher, callback, [args]) 
   
 
   
 
    
This convinience macro rolls both ev_init and ev_TYPE_set macrocalls into a single call. This is the most convinient method to initialisea watcher. The same limitations apply, of course.
 
   
 
   
 
    ev_TYPE_start (loop *, ev_TYPE *watcher) 
   
 
   
 
    
Starts (activates) the given watcher. Only active watchers will receiveevents. If the watcher is already active nothing will happen.
 
   
 
   
 
    ev_TYPE_stop (loop *, ev_TYPE *watcher) 
   
 
   
 
    
Stops the given watcher again (if active) and clears the pendingstatus. It is possible that stopped watchers are pending (for example,non-repeating timers are being stopped when they become pending), butev_TYPE_stop ensures that the watcher is neither active nor pending. Ifyou want to free or reuse the memory used by the watcher it is therefore agood idea to always call its ev_TYPE_stop function.
 
   
 
   
 
    bool ev_is_active (ev_TYPE *watcher) 
   
 
   
 
    
Returns a true value iff the watcher is active (i.e. it has been startedand not yet been stopped). As long as a watcher is active you must not modifyit.
 
   
 
   
 
    bool ev_is_pending (ev_TYPE *watcher) 
   
 
   
 
    
Returns a true value iff the watcher is pending, (i.e. it has outstandingevents but its callback has not yet been invoked). As long as a watcheris pending (but not active) you must not call an init function on it (butev_TYPE_set is safe), you must not change its priority, and you mustmake sure the watcher is available to libev (e.g. you cannot free ()it).
 
   
 
   
 
    callback ev_cb (ev_TYPE *watcher) 
   
 
   
 
    
Returns the callback currently set on the watcher.
 
   
 
   
 
    ev_cb_set (ev_TYPE *watcher, callback) 
   
 
   
 
    
Change the callback. You can change the callback at virtually any time(modulo threads).
 
   
 
   
 
    ev_set_priority (ev_TYPE *watcher, priority) 
   
 
   
 
    int ev_priority (ev_TYPE *watcher) 
   
 
   
 
    
Set and query the priority of the watcher. The priority is a smallinteger between EV_MAXPRI (default: 2) and EV_MINPRI(default: -2). Pending watchers with higher priority will be invokedbefore watchers with lower priority, but priority will not keep watchersfrom being executed (except for ev_idle watchers).
 
   
 
   
 
    
This means that priorities are only used for ordering callbackinvocation after new events have been received. This is useful, forexample, to reduce latency after idling, or more often, to bind twowatchers on the same event and make sure one is called first.
 
   
 
   
 
    
If you need to suppress invocation when higher priority events are pendingyou need to look at ev_idle watchers, which provide this functionality.
 
   
 
   
 
    
You must not change the priority of a watcher as long as it is active orpending.
 
   
 
   
 
    
The default priority used by watchers when no priority has been set isalways 0, which is supposed to not be too high and not be too low :).
 
   
 
   
 
    
Setting a priority outside the range of EV_MINPRI to EV_MAXPRI isfine, as long as you do not mind that the priority value you query mightor might not have been adjusted to be within valid range.
 
   
 
   
 
    ev_invoke (loop, ev_TYPE *watcher, int revents) 
   
 
   
 
    
Invoke the watcher with the given loop and revents. Neitherloop nor revents need to be valid as long as the watcher callbackcan deal with that fact.
 
   
 
   
 
    int ev_clear_pending (loop, ev_TYPE *watcher) 
   
 
   
 
    
If the watcher is pending, this function returns clears its pending statusand returns its revents bitset (as if its callback was invoked). If thewatcher isn't pending it does nothing and returns 0.
 
   
 
  
 
  
 
 
  
ASSOCIATING CUSTOM DATA WITH A WATCHER
 
  
Each watcher has, by default, a member void *data that you can changeand read at any time, libev will completely ignore it. This can be usedto associate arbitrary data with your watcher. If you need more data anddon't want to allocate memory and store a pointer to it in that datamember, you can also ``subclass'' the watcher type and provide your owndata:
 
  
 
   

     struct my_io {  
    
　　struct ev_io io;  
    
　　int otherfd;  
    
　　void *somedata;  
    
　　struct whatever *mostinteresting;  
    
} 
   
 
  
 
  
And since your callback will be called with a pointer to the watcher, youcan cast it back to your own type:
 
  
 
   

     static void my_cb (struct ev_loop *loop, struct ev_io *w_, int revents)  
    
{  
    
　　struct my_io *w = (struct my_io *)w_; 
    
 　...  
    
} 
   
 
  
 
  
More interesting and less C-conformant ways of casting your callback typeinstead have been omitted.
 
  
Another common scenario is having some data structure with multiplewatchers:
 
  
 
   

     struct my_biggy {  
    
　　int some_data;  
    
　　ev_timer t1;  
    
　　ev_timer t2;  
    
} 
   
 
  
 
  
In this case getting the pointer to my_biggy is a bit more complicated,you need to use offsetof:
 
  
 
   

     #include <stddef.h> 
    
static void t1_cb (EV_P_ struct ev_timer *w, int revents) {  
    
　　struct my_biggy big = (struct my_biggy * (((char *)w) - offsetof (struct my_biggy, t1));  
    
} 
    
 
    
static void t2_cb (EV_P_ struct ev_timer *w, int revents) {  
    
　　struct my_biggy big = (struct my_biggy * (((char *)w) - offsetof (struct my_biggy, t2));  
    
} 
   
 
  
 
  
 
  
WATCHER TYPES
 
  
This section describes each watcher in detail, but will not repeatinformation given in the last section. Any initialisation/set macros,functions and members specific to the watcher type are explained.
 
  
Members are additionally marked with either [read-only], meaning that,while the watcher is active, you can look at the member and expect somesensible content, but you must not modify it (you can modify it while thewatcher is stopped to your hearts content), or [read-write], whichmeans you can expect it to have some sensible content while the watcheris active, but you can also modify it. Modifying it may not do somethingsensible or take immediate effect (or do anything at all), but libev willnot crash or malfunction in any way. 
 
  
 
   Title本节将详细描述每一种watcher，但不会重复先前章节里出现过的内容。相关的宏、函数 、对象成员之前都已经解释过了。 
   
如果成员被标记为 
   [read-only]，则表明当Watcher运行时，你可以查看成员和获取相关的内容，但不能进行修改（watcher 停止时，方可以修改）。当为[ 
   read-write  
   
]，意味这你不但可以获取相关内容，同时你也可以对内容进行修改。修改可能产生无效值，或者不能立即生效，但这不会导致libev 挂掉或者故障。 
  
 
  
 
 
  
ev_io - is this file descriptor readable or writable?
 
  
I/O watchers check whether a file descriptor is readable or writablein each iteration of the event loop, or, more precisely, when readingwould not block the process and writing would at least be able to writesome data. This behaviour is called level-triggering because you keepreceiving events as long as the condition persists. Remember you can stopthe watcher if you don't want to act on the event and neither want toreceive future events.
 
  
In general you can register as many read and/or write event watchers perfd as you want (as long as you don't confuse yourself). Setting all filedescriptors to non-blocking mode is also usually a good idea (but notrequired if you know what you are doing).
 
  
If you must do this, then force the use of a known-to-be-good backend(at the time of this writing, this includes only EVBACKEND_SELECT andEVBACKEND_POLL).
 
  
Another thing you have to watch out for is that it is quite easy toreceive ``spurious'' readiness notifications, that is your callback mightbe called with EV_READ but a subsequent read(2) will actually blockbecause there is no data. Not only are some backends known to create alot of those (for example solaris ports), it is very easy to get intothis situation even with a relatively standard program structure. Thusit is best to always use non-blocking I/O: An extra read(2) returningEAGAIN is far preferable to a program hanging until some data arrives.
 
  
If you cannot run the fd in non-blocking mode (for example you should notplay around with an Xlib connection), then you have to seperately re-testwhether a file descriptor is really ready with a known-to-be good interfacesuch as poll (fortunately in our Xlib example, Xlib already does this onits own, so its quite safe to use).
 
  
 
 
  
The special problem of disappearing file descriptors
 
  
Some backends (e.g. kqueue, epoll) need to be told about closing a filedescriptor (either by calling close explicitly or by any other means,such as dup). The reason is that you register interest in some filedescriptor, but when it goes away, the operating system will silently dropthis interest. If another file descriptor with the same number then isregistered with libev, there is no efficient way to see that this is, infact, a different file descriptor.
 
  
To avoid having to explicitly tell libev about such cases, libev followsthe following policy: Each time ev_io_set is being called, libevwill assume that this is potentially a new file descriptor, otherwiseit is assumed that the file descriptor stays the same. That means thatyou have to call ev_io_set (or ev_io_init) when you change thedescriptor even if the file descriptor number itself did not change.
 
  
This is how one would do it normally anyway, the important point is thatthe libev application should not optimise around libev but should leaveoptimisations to libev.
 
  
 
 
  
The special problem of dup'ed file descriptors
 
  
Some backends (e.g. epoll), cannot register events for file descriptors,but only events for the underlying file descriptions. That means when youhave dup ()'ed file descriptors or weirder constellations, and registerevents for them, only one file descriptor might actually receive events.
 
  
There is no workaround possible except not registering eventsfor potentially dup ()'ed file descriptors, or to resort toEVBACKEND_SELECT or EVBACKEND_POLL.
 
  
 
 
  
The special problem of fork
 
  
Some backends (epoll, kqueue) do not support fork () at all or exhibituseless behaviour. Libev fully supports fork, but needs to be told aboutit in the child.
 
  
To support fork in your programs, you either have to callev_default_fork () or ev_loop_fork () after a fork in the child,enable EVFLAG_FORKCHECK, or resort to EVBACKEND_SELECT orEVBACKEND_POLL.
 
  
 
 
  
The special problem of SIGPIPE
 
  
While not really specific to libev, it is easy to forget about SIGPIPE:when reading from a pipe whose other end has been closed, your programgets send a SIGPIPE, which, by default, aborts your program. For mostprograms this is sensible behaviour, for daemons, this is usuallyundesirable.
 
  
So when you encounter spurious, unexplained daemon exits, make sure youignore SIGPIPE (and maybe make sure you log the exit status of your daemonsomewhere, as that would have given you a big clue).
 
  
 
 
  
Watcher-Specific Functions
 
  
 
   
 
    ev_io_init (ev_io *, callback, int fd, int events) 
   
 
   
 
    ev_io_set (ev_io *, int fd, int events) 
   
 
   
 
    
Configures an ev_io watcher. The fd is the file descriptor torceeive events for and events is either EV_READ, EV_WRITE orEV_READ | EV_WRITE to receive the given events.
 
   
 
   
 
    int fd [read-only] 
   
 
   
 
    
The file descriptor being watched.
 
   
 
   
 
    int events [read-only] 
   
 
   
 
    
The events being watched.
 
   
 
  
 
  
 
 
  
Examples
 
  
Example: Call stdin_readable_cb when STDIN_FILENO has become, wellreadable, but only once. Since it is likely line-buffered, you couldattempt to read a whole line in the callback.
 
  
 static void stdin_readable_cb (struct ev_loop *loop, struct ev_io *w, int revents) { ev_io_stop (loop, w); .. read from stdin here (or from w->fd) and haqndle any I/O errors }
 
  
 ... struct ev_loop *loop = ev_default_init (0); struct ev_io stdin_readable; ev_io_init (&stdin_readable, stdin_readable_cb, STDIN_FILENO, EV_READ); ev_io_start (loop, &stdin_readable); ev_loop (loop, 0);
 
  
 
 
  
ev_timer - relative and optionally repeating timeouts
 
  
Timer watchers are simple relative timers that generate an event after agiven time, and optionally repeating in regular intervals after that.
 
  
The timers are based on real time, that is, if you register an event thattimes out after an hour and you reset your system clock to january lastyear, it will still time out after (roughly) and hour. ``Roughly'' becausedetecting time jumps is hard, and some inaccuracies are unavoidable (themonotonic clock option helps a lot here).
 
  
The relative timeouts are calculated relative to the ev_now ()time. This is usually the right thing as this timestamp refers to the timeof the event triggering whatever timeout you are modifying/starting. Ifyou suspect event processing to be delayed and you need to base the timeouton the current time, use something like this to adjust for this:
 
  
 ev_timer_set (&timer, after + ev_now () - ev_time (), 0.);
 
  
The callback is guarenteed to be invoked only after its timeout has passed,but if multiple timers become ready during the same loop iteration thenorder of execution is undefined.
 
  
 
 
  
Watcher-Specific Functions and Data Members
 
  
 
   
 
    ev_timer_init (ev_timer *, callback, ev_tstamp after, ev_tstamp repeat) 
   
 
   
 
    ev_timer_set (ev_timer *, ev_tstamp after, ev_tstamp repeat) 
   
 
   
 
    
Configure the timer to trigger after after seconds. If repeatis 0., then it will automatically be stopped once the timeout isreached. If it is positive, then the timer will automatically beconfigured to trigger again repeat seconds later, again, and again,until stopped manually.
 
   
 
   
 
    
The timer itself will do a best-effort at avoiding drift, that is, ifyou configure a timer to trigger every 10 seconds, then it will normallytrigger at exactly 10 second intervals. If, however, your program cannotkeep up with the timer (because it takes longer than those 10 seconds todo stuff) the timer will not fire more than once per event loop iteration.
 
   
 
   
 
    ev_timer_again (loop, ev_timer *) 
   
 
   
 
    
This will act as if the timer timed out and restart it again if it isrepeating. The exact semantics are:
 
   
 
   
 
    
If the timer is pending, its pending status is cleared.
 
   
 
   
 
    
If the timer is started but nonrepeating, stop it (as if it timed out).
 
   
 
   
 
    
If the timer is repeating, either start it if necessary (with therepeat value), or reset the running timer to the repeat value.
 
   
 
   
 
    
This sounds a bit complicated, but here is a useful and typicalexample: Imagine you have a tcp connection and you want a so-called idletimeout, that is, you want to be called when there have been, say, 60seconds of inactivity on the socket. The easiest way to do this is toconfigure an ev_timer with a repeat value of 60 and then callev_timer_again each time you successfully read or write some data. Ifyou go into an idle state where you do not expect data to travel on thesocket, you can ev_timer_stop the timer, and ev_timer_again willautomatically restart it if need be.
 
   
 
   
 
    
That means you can ignore the after value and ev_timer_startaltogether and only ever use the repeat value and ev_timer_again:
 
   
 
   
 
    
 ev_timer_init (timer, callback, 0., 5.); ev_timer_again (loop, timer); ... timer->again = 17.; ev_timer_again (loop, timer); ... timer->again = 10.; ev_timer_again (loop, timer);
 
   
 
   
 
    
This is more slightly efficient then stopping/starting the timer each timeyou want to modify its timeout value.
 
   
 
   
 
    ev_tstamp repeat [read-write] 
   
 
   
 
    
The current repeat value. Will be used each time the watcher times outor ev_timer_again is called and determines the next timeout (if any),which is also when any modifications are taken into account.
 
   
 
  
 
  
 
 
  
Examples
 
  
Example: Create a timer that fires after 60 seconds.
 
  
 static void one_minute_cb (struct ev_loop *loop, struct ev_timer *w, int revents) { .. one minute over, w is actually stopped right here }
 
  
 struct ev_timer mytimer; ev_timer_init (&mytimer, one_minute_cb, 60., 0.); ev_timer_start (loop, &mytimer);
 
  
Example: Create a timeout timer that times out after 10 seconds ofinactivity.
 
  
 static void timeout_cb (struct ev_loop *loop, struct ev_timer *w, int revents) { .. ten seconds without any activity }
 
  
 struct ev_timer mytimer; ev_timer_init (&mytimer, timeout_cb, 0., 10.); /* note, only repeat used */ ev_timer_again (&mytimer); /* start timer */ ev_loop (loop, 0);
 
  
 // and in some piece of code that gets executed on any "activity": // reset the timeout to start ticking again at 10 seconds ev_timer_again (&mytimer);
 
  
 
 
  
ev_periodic - to cron or not to cron?
 
  
Periodic watchers are also timers of a kind, but they are very versatile(and unfortunately a bit complex).
 
  
Unlike ev_timer's, they are not based on real time (or relative time)but on wallclock time (absolute time). You can tell a periodic watcherto trigger after some specific point in time. For example, if you tell aperiodic watcher to trigger in 10 seconds (by specifiying e.g. ev_now ()+ 10., that is, an absolute time not a delay) and then reset your systemclock to january of the previous year, then it will take more than yearto trigger the event (unlike an ev_timer, which would still triggerroughly 10 seconds later as it uses a relative timeout).
 
  
ev_periodics can also be used to implement vastly more complex timers,such as triggering an event on each ``midnight, local time'', or othercomplicated, rules.
 
  
As with timers, the callback is guarenteed to be invoked only when thetime (at) has passed, but if multiple periodic timers become readyduring the same loop iteration then order of execution is undefined.
 
  
 
 
  
Watcher-Specific Functions and Data Members
 
  
 
   
 
    ev_periodic_init (ev_periodic *, callback, ev_tstamp at, ev_tstamp interval, reschedule_cb) 
   
 
   
 
    ev_periodic_set (ev_periodic *, ev_tstamp after, ev_tstamp repeat, reschedule_cb) 
   
 
   
 
    
Lots of arguments, lets sort it out... There are basically three modes ofoperation, and we will explain them from simplest to complex:
 
   
 
  
 
  
     
   
  • absolute timer (at = time, interval = reschedule_cb = 0) 
    In this configuration the watcher triggers an event after the wallclocktime at has passed and doesn't repeat. It will not adjust when a timejump occurs, that is, if it is to be run at January 1st 2011 then it willrun when the system time reaches or surpasses this time.
     
    •  
   
  • repeating interval timer (at = offset, interval > 0, reschedule_cb = 0) 
    In this mode the watcher will always be scheduled to time out at the nextat + N * interval time (for some integer N, which can also be negative)and then repeat, regardless of any time jumps.
     
    This can be used to create timers that do not drift with respect to systemtime, for example, here is a ev_periodic that triggers each hour, onthe hour:
     
     ev_periodic_set (&periodic, 0., 3600., 0);
     
    This doesn't mean there will always be 3600 seconds in between triggers,but only that the the callback will be called when the system time shows afull hour (UTC), or more correctly, when the system time is evenly divisibleby 3600.
     
    Another way to think about it (for the mathematically inclined) is thatev_periodic will try to run the callback in this mode at the next possibletime where time = at (mod interval), regardless of any time jumps.
     
    For numerical stability it is preferable that the at value is nearev_now () (the current time), but there is no range requirement forthis value, and in fact is often specified as zero.
     
    Note also that there is an upper limit to how often a timer can fire (cpuspeed for example), so if interval is very small then timing stabilitywill of course detoriate. Libev itself tries to be exact to be about onemillisecond (if the OS supports it and the machine is fast enough).
     
    •  
   
  • manual reschedule mode (at and interval ignored, reschedule_cb = callback) 
    In this mode the values for interval and at are both beingignored. Instead, each time the periodic watcher gets scheduled, thereschedule callback will be called with the watcher as first, and thecurrent time as second argument.
     
    NOTE: This callback MUST NOT stop or destroy any periodic watcher,ever, or make ANY event loop modifications whatsoever.
     
    If you need to stop it, return now + 1e30 (or so, fudge fudge) and stopit afterwards (e.g. by starting an ev_prepare watcher, which is theonly event loop modification you are allowed to do).
     
    The callback prototype is ev_tstamp (*reschedule_cb)(struct ev_periodic*w, ev_tstamp now), e.g.:
     
     static ev_tstamp my_rescheduler (struct ev_periodic *w, ev_tstamp now) { return now + 60.; }
     
    It must return the next time to trigger, based on the passed time value(that is, the lowest time value larger than to the second argument). Itwill usually be called just before the callback will be triggered, butmight be called at other times, too.
     
    NOTE: This callback must always return a time that is higher than orequal to the passed now value >.
     
    This can be used to create very complex timers, such as a timer thattriggers on ``next midnight, local time''. To do this, you would calculate thenext midnight after now and return the timestamp value for this. Howyou do this is, again, up to you (but it is not trivial, which is the mainreason I omitted it as an example).
     
    •  
  
 
  
 
   
 
    ev_periodic_again (loop, ev_periodic *) 
   
 
   
 
    
Simply stops and restarts the periodic watcher again. This is only usefulwhen you changed some parameters or the reschedule callback would returna different time than the last time it was called (e.g. in a crond likeprogram when the crontabs have changed).
 
   
 
   
 
    ev_tstamp ev_periodic_at (ev_periodic *) 
   
 
   
 
    
When active, returns the absolute time that the watcher is supposed totrigger next.
 
   
 
   
 
    ev_tstamp offset [read-write] 
   
 
   
 
    
When repeating, this contains the offset value, otherwise this is theabsolute point in time (the at value passed to ev_periodic_set).
 
   
 
   
 
    
Can be modified any time, but changes only take effect when the periodictimer fires or ev_periodic_again is being called.
 
   
 
   
 
    ev_tstamp interval [read-write] 
   
 
   
 
    
The current interval value. Can be modified any time, but changes onlytake effect when the periodic timer fires or ev_periodic_again is beingcalled.
 
   
 
   
 
    ev_tstamp (*reschedule_cb)(struct ev_periodic *w, ev_tstamp now) [read-write] 
   
 
   
 
    
The current reschedule callback, or 0, if this functionality isswitched off. Can be changed any time, but changes only take effect whenthe periodic timer fires or ev_periodic_again is being called.
 
   
 
  
 
  
 
 
  
Examples
 
  
Example: Call a callback every hour, or, more precisely, whenever thesystem clock is divisible by 3600. The callback invocation times havepotentially a lot of jittering, but good long-term stability.
 
  
 static void clock_cb (struct ev_loop *loop, struct ev_io *w, int revents) { ... its now a full hour (UTC, or TAI or whatever your clock follows) }
 
  
 struct ev_periodic hourly_tick; ev_periodic_init (&hourly_tick, clock_cb, 0., 3600., 0); ev_periodic_start (loop, &hourly_tick);
 
  
Example: The same as above, but use a reschedule callback to do it:
 
  
 #include <math.h>
 
  
 static ev_tstamp my_scheduler_cb (struct ev_periodic *w, ev_tstamp now) { return fmod (now, 3600.) + 3600.; }
 
  
 ev_periodic_init (&hourly_tick, clock_cb, 0., 0., my_scheduler_cb);
 
  
Example: Call a callback every hour, starting now:
 
  
 struct ev_periodic hourly_tick; ev_periodic_init (&hourly_tick, clock_cb, fmod (ev_now (loop), 3600.), 3600., 0); ev_periodic_start (loop, &hourly_tick);
 
  
 
 
  
ev_signal - signal me when a signal gets signalled!
 
  
Signal watchers will trigger an event when the process receives a specificsignal one or more times. Even though signals are very asynchronous, libevwill try it's best to deliver signals synchronously, i.e. as part of thenormal event processing, like any other event.
 
  
You can configure as many watchers as you like per signal. Only when thefirst watcher gets started will libev actually register a signal watcherwith the kernel (thus it coexists with your own signal handlers as longas you don't register any with libev). Similarly, when the last signalwatcher for a signal is stopped libev will reset the signal handler toSIG_DFL (regardless of what it was set to before).
 
  
If possible and supported, libev will install its handlers withSA_RESTART behaviour enabled, so syscalls should not be undulyinterrupted. If you have a problem with syscalls getting interrupted bysignals you can block all signals in an ev_check watcher and unblockthem in an ev_prepare watcher.
 
  
 
 
  
Watcher-Specific Functions and Data Members
 
  
 
   
 
    ev_signal_init (ev_signal *, callback, int signum) 
   
 
   
 
    ev_signal_set (ev_signal *, int signum) 
   
 
   
 
    
Configures the watcher to trigger on the given signal number (usually oneof the SIGxxx constants).
 
   
 
   
 
    int signum [read-only] 
   
 
   
 
    
The signal the watcher watches out for.
 
   
 
  
 
  
 
 
  
Examples
 
  
Example: Try to exit cleanly on SIGINT and SIGTERM.
 
  
 static void sigint_cb (struct ev_loop *loop, struct ev_signal *w, int revents) { ev_unloop (loop, EVUNLOOP_ALL); }
 
  
 struct ev_signal signal_watcher; ev_signal_init (&signal_watcher, sigint_cb, SIGINT); ev_signal_start (loop, &sigint_cb);
 
  
 
 
  
ev_child - watch out for process status changes
 
  
Child watchers trigger when your process receives a SIGCHLD in response tosome child status changes (most typically when a child of yours dies). Itis permissible to install a child watcher after the child has beenforked (which implies it might have already exited), as long as the eventloop isn't entered (or is continued from a watcher).
 
  
Only the default event loop is capable of handling signals, and thereforeyou can only rgeister child watchers in the default event loop.
 
  
 
 
  
Process Interaction
 
  
Libev grabs SIGCHLD as soon as the default event loop isinitialised. This is necessary to guarantee proper behaviour even ifthe first child watcher is started after the child exits. The occuranceof SIGCHLD is recorded asynchronously, but child reaping is donesynchronously as part of the event loop processing. Libev always reaps allchildren, even ones not watched.
 
  
 
 
  
Overriding the Built-In Processing
 
  
Libev offers no special support for overriding the built-in childprocessing, but if your application collides with libev's default childhandler, you can override it easily by installing your own handler forSIGCHLD after initialising the default loop, and making sure thedefault loop never gets destroyed. You are encouraged, however, to use anevent-based approach to child reaping and thus use libev's support forthat, so other libev users can use ev_child watchers freely.
 
  
 
 
  
Watcher-Specific Functions and Data Members
 
  
 
   
 
    ev_child_init (ev_child *, callback, int pid, int trace) 
   
 
   
 
    ev_child_set (ev_child *, int pid, int trace) 
   
 
   
 
    
Configures the watcher to wait for status changes of process pid (orany process if pid is specified as 0). The callback can lookat the rstatus member of the ev_child watcher structure to seethe status word (use the macros from sys/wait.h and see your systemswaitpid documentation). The rpid member contains the pid of theprocess causing the status change. trace must be either 0 (onlyactivate the watcher when the process terminates) or 1 (additionallyactivate the watcher when the process is stopped or continued).
 
   
 
   
 
    int pid [read-only] 
   
 
   
 
    
The process id this watcher watches out for, or 0, meaning any process id.
 
   
 
   
 
    int rpid [read-write] 
   
 
   
 
    
The process id that detected a status change.
 
   
 
   
 
    int rstatus [read-write] 
   
 
   
 
    
The process exit/trace status caused by rpid (see your systemswaitpid and sys/wait.h documentation for details).
 
   
 
  
 
  
 
 
  
Examples
 
  
Example: fork() a new process and install a child handler to wait forits completion.
 
  
 ev_child cw;
 
  
 static void child_cb (EV_P_ struct ev_child *w, int revents) { ev_child_stop (EV_A_ w); printf ("process %d exited with status %x\n", w->rpid, w->rstatus); }
 
  
 pid_t pid = fork ();
 
  
 if (pid < 0) // error else if (pid == 0) { // the forked child executes here exit (1); } else { ev_child_init (&cw, child_cb, pid, 0); ev_child_start (EV_DEFAULT_ &cw); }
 
  
 
 
  
ev_stat - did the file attributes just change?
 
  
This watches a filesystem path for attribute changes. That is, it callsstat regularly (or when the OS says it changed) and sees if it changedcompared to the last time, invoking the callback if it did.
 
  
The path does not need to exist: changing from ``path exists'' to ``path doesnot exist'' is a status change like any other. The condition ``path doesnot exist'' is signified by the st_nlink field being zero (which isotherwise always forced to be at least one) and all the other fields ofthe stat buffer having unspecified contents.
 
  
The path should be absolute and must not end in a slash. If it isrelative and your working directory changes, the behaviour is undefined.
 
  
Since there is no standard to do this, the portable implementation simplycalls stat (2) regularly on the path to see if it changed somehow. Youcan specify a recommended polling interval for this case. If you specifya polling interval of 0 (highly recommended!) then a suitable,unspecified default value will be used (which you can expect to be aroundfive seconds, although this might change dynamically). Libev will alsoimpose a minimum interval which is currently around 0.1, but thatsusually overkill.
 
  
This watcher type is not meant for massive numbers of stat watchers,as even with OS-supported change notifications, this can beresource-intensive.
 
  
At the time of this writing, only the Linux inotify interface isimplemented (implementing kqueue support is left as an exercise for thereader, note, however, that the author sees no way of implementing ev_statsemantics with kqueue). Inotify will be used to give hints only and shouldnot change the semantics of ev_stat watchers, which means that libevsometimes needs to fall back to regular polling again even with inotify,but changes are usually detected immediately, and if the file exists therewill be no polling.
 
  
 
 
  
ABI Issues (Largefile Support)
 
  
Libev by default (unless the user overrides this) uses the defaultcompilation environment, which means that on systems with optionallydisabled large file support, you get the 32 bit version of the statstructure. When using the library from programs that change the ABI touse 64 bit file offsets the programs will fail. In that case you have tocompile libev with the same flags to get binary compatibility. This isobviously the case with any flags that change the ABI, but the problem ismost noticably with ev_stat and largefile support.
 
  
 
 
  
Inotify
 
  
When inotify (7) support has been compiled into libev (generally onlyavailable on Linux) and present at runtime, it will be used to speed upchange detection where possible. The inotify descriptor will be created lazilywhen the first ev_stat watcher is being started.
 
  
Inotify presence does not change the semantics of ev_stat watchersexcept that changes might be detected earlier, and in some cases, to avoidmaking regular stat calls. Even in the presence of inotify supportthere are many cases where libev has to resort to regular stat polling.
 
  
(There is no support for kqueue, as apparently it cannot be used toimplement this functionality, due to the requirement of having a filedescriptor open on the object at all times).
 
  
 
 
  
The special problem of stat time resolution
 
  
The stat () syscall only supports full-second resolution portably, andeven on systems where the resolution is higher, many filesystems stillonly support whole seconds.
 
  
That means that, if the time is the only thing that changes, you caneasily miss updates: on the first update, ev_stat detects a change andcalls your callback, which does something. When there is another updatewithin the same second, ev_stat will be unable to detect it as the statdata does not change.
 
  
The solution to this is to delay acting on a change for slightly morethan a second (or till slightly after the next full second boundary), usinga roughly one-second-delay ev_timer (e.g. ev_timer_set (w, 0., 1.02);ev_timer_again (loop, w)).
 
  
The .02 offset is added to work around small timing inconsistenciesof some operating systems (where the second counter of the current timemight be be delayed. One such system is the Linux kernel, where a call togettimeofday might return a timestamp with a full second later thana subsequent time call - if the equivalent of time () is used toupdate file times then there will be a small window where the kernel usesthe previous second to update file times but libev might already executethe timer callback).
 
  
 
 
  
Watcher-Specific Functions and Data Members
 
  
 
   
 
    ev_stat_init (ev_stat *, callback, const char *path, ev_tstamp interval) 
   
 
   
 
    ev_stat_set (ev_stat *, const char *path, ev_tstamp interval) 
   
 
   
 
    
Configures the watcher to wait for status changes of the givenpath. The interval is a hint on how quickly a change is expected tobe detected and should normally be specified as 0 to let libev choosea suitable value. The memory pointed to by path must point to the samepath for as long as the watcher is active.
 
   
 
   
 
    
The callback will receive EV_STAT when a change was detected, relativeto the attributes at the time the watcher was started (or the last changewas detected).
 
   
 
   
 
    ev_stat_stat (loop, ev_stat *) 
   
 
   
 
    
Updates the stat buffer immediately with new values. If you change thewatched path in your callback, you could call this function to avoiddetecting this change (while introducing a race condition if you are notthe only one changing the path). Can also be useful simply to find out thenew values.
 
   
 
   
 
    ev_statdata attr [read-only] 
   
 
   
 
    
The most-recently detected attributes of the file. Although the type isev_statdata, this is usually the (or one of the) struct stat typessuitable for your system, but you can only rely on the POSIX-standardisedmembers to be present. If the st_nlink member is 0, then there wassome error while stating the file.
 
   
 
   
 
    ev_statdata prev [read-only] 
   
 
   
 
    
The previous attributes of the file. The callback gets invoked wheneverprev != attr, or, more precisely, one or more of these membersdiffer: st_dev, st_ino, st_mode, st_nlink, st_uid,st_gid, st_rdev, st_size, st_atime, st_mtime, st_ctime.
 
   
 
   
 
    ev_tstamp interval [read-only] 
   
 
   
 
    
The specified interval.
 
   
 
   
 
    const char *path [read-only] 
   
 
   
 
    
The filesystem path that is being watched.
 
   
 
  
 
  
 
 
  
Examples
 
  
Example: Watch /etc/passwd for attribute changes.
 
  
 
   

     static void passwd_cb (struct ev_loop *loop, ev_stat *w, int revents) {     
   
 
   
/* /etc/passwd changed in some way */
 
   
if (w->attr.st_nlink) { 
 
   
printf ("passwd current size %ld\n", (long)w->attr.st_size); 
 
   
printf ("passwd current atime %ld\n", (long)w->attr.st_mtime); 
 
   
printf ("passwd current mtime %ld\n", (long)w->attr.st_mtime); 
 
   
} else/* you shalt not abuse printf for puts */ 
 
   
puts ("wow, /etc/passwd is not there, expect problems. ""if this is windows, they already arrived\n");
 
   
｝
 
   
 ... ev_stat passwd;
ev_stat_init (&passwd, passwd_cb, "/etc/passwd", 0.); 
 
   
ev_stat_start (loop, &passwd);
 
  
 
  
Example: Like above, but additionally use a one-second delay so we do notmiss updates (however, frequent updates will delay processing, too, soone might do the work both on ev_stat callback invocation and onev_timer callback invocation).
 
  
 
 
  
 
   

     static ev_stat passwd; static ev_timer timer; 
    
static void timer_cb (EV_P_ ev_timer *w, int revents) {  
   
 
   
ev_timer_stop (EV_A_ w);
/* now it's one second after the most recent passwd change */
 
   
}
static void stat_cb (EV_P_ ev_stat *w, int revents) { 
 
   
/* reset the one-second timer */
 
   
ev_timer_again (EV_A_ &timer);}
 
   
 
 
   
 ... ev_stat_init (&passwd, stat_cb, "/etc/passwd", 0.); 
 
   
ev_stat_start (loop, &passwd); 
 
   
ev_timer_init (&timer, timer_cb, 0., 1.02);
 
  
 
  
 
 
  
ev_idle - when you've got nothing better to do...
 
  
Idle watchers trigger events when no other events of the same or higherpriority are pending (prepare, check and other idle watchers do notcount).
 
  
That is, as long as your process is busy handling sockets or timeouts(or even signals, imagine) of the same or higher priority it will not betriggered. But when your process is idle (or only lower-priority watchersare pending), the idle watchers are being called once per event loopiteration - until stopped, that is, or your process receives more eventsand becomes busy again with higher priority stuff.
 
  
The most noteworthy effect is that as long as any idle watchers areactive, the process will not block when waiting for new events.
 
  
Apart from keeping your process non-blocking (which is a usefuleffect on its own sometimes), idle watchers are a good place to do``pseudo-background processing'', or delay processing stuff to after theevent loop has handled all outstanding events.
 
  
 
 
  
Watcher-Specific Functions and Data Members
 
  
 
   
 
    ev_idle_init (ev_signal *, callback) 
   
 
   
 
    
Initialises and configures the idle watcher - it has no parameters of anykind. There is a ev_idle_set macro, but using it is utterly pointless,believe me.
 
   
 
  
 
  
 
 
  
Examples
 
  
Example: Dynamically allocate an ev_idle watcher, start it, and in thecallback, free it. Also, use no error checking, as usual.
 
  
 static void idle_cb (struct ev_loop *loop, struct ev_idle *w, int revents) { free (w); // now do something you wanted to do when the program has // no longer anything immediate to do. }
 
  
 struct ev_idle *idle_watcher = malloc (sizeof (struct ev_idle)); ev_idle_init (idle_watcher, idle_cb); ev_idle_start (loop, idle_cb);
 
  
 
 
  
ev_prepare and ev_check - customise your event loop!
 
  
Prepare and check watchers are usually (but not always) used in tandem:prepare watchers get invoked before the process blocks and check watchersafterwards.
 
  
You must not call ev_loop or similar functions that enterthe current event loop from either ev_prepare or ev_checkwatchers. Other loops than the current one are fine, however. Therationale behind this is that you do not need to check for recursion inthose watchers, i.e. the sequence will always be ev_prepare, blocking,ev_check so if you have one watcher of each kind they will always becalled in pairs bracketing the blocking call.
 
  
Their main purpose is to integrate other event mechanisms into libev andtheir use is somewhat advanced. This could be used, for example, to trackvariable changes, implement your own watchers, integrate net-snmp or acoroutine library and lots more. They are also occasionally useful ifyou cache some data and want to flush it before blocking (for example,in X programs you might want to do an XFlush () in an ev_preparewatcher).
 
  
This is done by examining in each prepare call which file descriptors needto be watched by the other library, registering ev_io watchers forthem and starting an ev_timer watcher for any timeouts (many librariesprovide just this functionality). Then, in the check watcher you check forany events that occured (by checking the pending status of all watchersand stopping them) and call back into the library. The I/O and timercallbacks will never actually be called (but must be valid nevertheless,because you never know, you know?).
 
  
As another example, the Perl Coro module uses these hooks to integratecoroutines into libev programs, by yielding to other active coroutinesduring each prepare and only letting the process block if no coroutinesare ready to run (it's actually more complicated: it only runs coroutineswith priority higher than or equal to the event loop and one coroutineof lower priority, but only once, using idle watchers to keep the eventloop from blocking if lower-priority coroutines are active, thus mappinglow-priority coroutines to idle/background tasks).
 
  
It is recommended to give ev_check watchers highest (EV_MAXPRI)priority, to ensure that they are being run before any other watchersafter the poll. Also, ev_check watchers (and ev_prepare watchers,too) should not activate (``feed'') events into libev. While libev fullysupports this, they might get executed before other ev_check watchersdid their job. As ev_check watchers are often used to embed other(non-libev) event loops those other event loops might be in an unusablestate until their ev_check watcher ran (always remind yourself tocoexist peacefully with others).
 
  
 
 
  
Watcher-Specific Functions and Data Members
 
  
 
   
 
    ev_prepare_init (ev_prepare *, callback) 
   
 
   
 
    ev_check_init (ev_check *, callback) 
   
 
   
 
    
Initialises and configures the prepare or check watcher - they have noparameters of any kind. There are ev_prepare_set and ev_check_setmacros, but using them is utterly, utterly and completely pointless.
 
   
 
  
 
  
 
 
  
Examples
 
  
There are a number of principal ways to embed other event loops or modulesinto libev. Here are some ideas on how to include libadns into libev(there is a Perl module named EV::ADNS that does this, which you coulduse as a working example. Another Perl module named EV::Glib embeds aGlib main context into libev, and finally, Glib::EV embeds EV into theGlib event loop).
 
  
Method 1: Add IO watchers and a timeout watcher in a prepare handler,and in a check watcher, destroy them and call into libadns. What followsis pseudo-code only of course. This requires you to either use a lowpriority for the check watcher or use ev_clear_pending explicitly, asthe callbacks for the IO/timeout watchers might not have been called yet.
 
  
 static ev_io iow [nfd]; static ev_timer tw;
 
  
 static void io_cb (ev_loop *loop, ev_io *w, int revents) { }
 
  
 // create io watchers for each fd and a timer before blocking static void adns_prepare_cb (ev_loop *loop, ev_prepare *w, int revents) { int timeout = 3600000; struct pollfd fds [nfd]; // actual code will need to loop here and realloc etc. adns_beforepoll (ads, fds, &nfd, &timeout, timeval_from (ev_time ()));
 
  
 /* the callback is illegal, but won't be called as we stop during check */ ev_timer_init (&tw, 0, timeout * 1e-3); ev_timer_start (loop, &tw);
 
  
 // create one ev_io per pollfd for (int i = 0; i < nfd; ++i) { ev_io_init (iow + i, io_cb, fds [i].fd, ((fds [i].events & POLLIN ? EV_READ : 0) | (fds [i].events & POLLOUT ? EV_WRITE : 0)));
 
  
 fds [i].revents = 0; ev_io_start (loop, iow + i); } }
 
  
 // stop all watchers after blocking static void adns_check_cb (ev_loop *loop, ev_check *w, int revents) { ev_timer_stop (loop, &tw);
 
  
 for (int i = 0; i < nfd; ++i) { // set the relevant poll flags // could also call adns_processreadable etc. here struct pollfd *fd = fds + i; int revents = ev_clear_pending (iow + i); if (revents & EV_READ ) fd->revents |= fd->events & POLLIN; if (revents & EV_WRITE) fd->revents |= fd->events & POLLOUT;
 
  
 // now stop the watcher ev_io_stop (loop, iow + i); }
 
  
 adns_afterpoll (adns, fds, nfd, timeval_from (ev_now (loop)); }
 
  
Method 2: This would be just like method 1, but you run adns_afterpollin the prepare watcher and would dispose of the check watcher.
 
  
Method 3: If the module to be embedded supports explicit eventnotification (adns does), you can also make use of the actual watchercallbacks, and only destroy/create the watchers in the prepare watcher.
 
  
 static void timer_cb (EV_P_ ev_timer *w, int revents) { adns_state ads = (adns_state)w->data; update_now (EV_A);
 
  
 adns_processtimeouts (ads, &tv_now); }
 
  
 static void io_cb (EV_P_ ev_io *w, int revents) { adns_state ads = (adns_state)w->data; update_now (EV_A);
 
  
 if (revents & EV_READ ) adns_processreadable (ads, w->fd, &tv_now); if (revents & EV_WRITE) adns_processwriteable (ads, w->fd, &tv_now); }
 
  
 // do not ever call adns_afterpoll
 
  
Method 4: Do not use a prepare or check watcher because the module youwant to embed is too inflexible to support it. Instead, youc na overridetheir poll function. The drawback with this solution is that the mainloop is now no longer controllable by EV. The Glib::EV module doesthis.
 
  
 static gint event_poll_func (GPollFD *fds, guint nfds, gint timeout) { int got_events = 0;
 
  
 for (n = 0; n < nfds; ++n) // create/start io watcher that sets the relevant bits in fds[n] and increment got_events
 
  
 if (timeout >= 0) // create/start timer
 
  
 // poll ev_loop (EV_A_ 0);
 
  
 // stop timer again if (timeout >= 0) ev_timer_stop (EV_A_ &to);
 
  
 // stop io watchers again - their callbacks should have set for (n = 0; n < nfds; ++n) ev_io_stop (EV_A_ iow [n]);
 
  
 return got_events; }
 
  
 
 
  
ev_embed - when one backend isn't enough...
 
  
This is a rather advanced watcher type that lets you embed one event loopinto another (currently only ev_io events are supported in the embeddedloop, other types of watchers might be handled in a delayed or incorrectfashion and must not be used).
 
  
There are primarily two reasons you would want that: work around bugs andprioritise I/O.
 
  
As an example for a bug workaround, the kqueue backend might only supportsockets on some platform, so it is unusable as generic backend, but youstill want to make use of it because you have many sockets and it scalesso nicely. In this case, you would create a kqueue-based loop and embed itinto your default loop (which might use e.g. poll). Overall operation willbe a bit slower because first libev has to poll and then call kevent, butat least you can use both at what they are best.
 
  
As for prioritising I/O: rarely you have the case where some fds haveto be watched and handled very quickly (with low latency), and evenpriorities and idle watchers might have too much overhead. In this caseyou would put all the high priority stuff in one loop and all the rest ina second one, and embed the second one in the first.
 
  
As long as the watcher is active, the callback will be invoked every timethere might be events pending in the embedded loop. The callback must thencall ev_embed_sweep (mainloop, watcher) to make a single sweep and invoketheir callbacks (you could also start an idle watcher to give the embeddedloop strictly lower priority for example). You can also set the callbackto 0, in which case the embed watcher will automatically execute theembedded loop sweep.
 
  
As long as the watcher is started it will automatically handle events. Thecallback will be invoked whenever some events have been handled. You canset the callback to 0 to avoid having to specify one if you are notinterested in that.
 
  
Also, there have not currently been made special provisions for forking:when you fork, you not only have to call ev_loop_fork on both loops,but you will also have to stop and restart any ev_embed watchersyourself.
 
  
Unfortunately, not all backends are embeddable, only the ones returned byev_embeddable_backends are, which, unfortunately, does not include anyportable one.
 
  
So when you want to use this feature you will always have to be preparedthat you cannot get an embeddable loop. The recommended way to get aroundthis is to have a separate variables for your embeddable loop, try tocreate it, and if that fails, use the normal loop for everything.
 
  
 
 
  
Watcher-Specific Functions and Data Members
 
  
 
   
 
    ev_embed_init (ev_embed *, callback, struct ev_loop *embedded_loop) 
   
 
   
 
    ev_embed_set (ev_embed *, callback, struct ev_loop *embedded_loop) 
   
 
   
 
    
Configures the watcher to embed the given loop, which must beembeddable. If the callback is 0, then ev_embed_sweep will beinvoked automatically, otherwise it is the responsibility of the callbackto invoke it (it will continue to be called until the sweep has been done,if you do not want thta, you need to temporarily stop the embed watcher).
 
   
 
   
 
    ev_embed_sweep (loop, ev_embed *) 
   
 
   
 
    
Make a single, non-blocking sweep over the embedded loop. This workssimilarly to ev_loop (embedded_loop, EVLOOP_NONBLOCK), but in the mostapropriate way for embedded loops.
 
   
 
   
 
    struct ev_loop *other [read-only] 
   
 
   
 
    
The embedded event loop.
 
   
 
  
 
  
 
 
  
Examples
 
  
Example: Try to get an embeddable event loop and embed it into the defaultevent loop. If that is not possible, use the default loop. The defaultloop is stored in loop_hi, while the mebeddable loop is stored inloop_lo (which is loop_hi in the acse no embeddable loop can beused).
 
  
 struct ev_loop *loop_hi = ev_default_init (0); struct ev_loop *loop_lo = 0; struct ev_embed embed; // see if there is a chance of getting one that works // (remember that a flags value of 0 means autodetection) loop_lo = ev_embeddable_backends () & ev_recommended_backends () ? ev_loop_new (ev_embeddable_backends () & ev_recommended_backends ()) : 0;
 
  
 // if we got one, then embed it, otherwise default to loop_hi if (loop_lo) { ev_embed_init (&embed, 0, loop_lo); ev_embed_start (loop_hi, &embed); } else loop_lo = loop_hi;
 
  
Example: Check if kqueue is available but not recommended and createa kqueue backend for use with sockets (which usually work with anykqueue implementation). Store the kqueue/socket-only event loop inloop_socket. (One might optionally use EVFLAG_NOENV, too).
 
  
 struct ev_loop *loop = ev_default_init (0); struct ev_loop *loop_socket = 0; struct ev_embed embed; if (ev_supported_backends () & ~ev_recommended_backends () & EVBACKEND_KQUEUE) if ((loop_socket = ev_loop_new (EVBACKEND_KQUEUE)) { ev_embed_init (&embed, 0, loop_socket); ev_embed_start (loop, &embed); }
 
  
 if (!loop_socket) loop_socket = loop;
 
  
 // now use loop_socket for all sockets, and loop for everything else
 
  
 
 
  
ev_fork - the audacity to resume the event loop after a fork
 
  
Fork watchers are called when a fork () was detected (usually becausewhoever is a good citizen cared to tell libev about it by callingev_default_fork or ev_loop_fork). The invocation is done before theevent loop blocks next and before ev_check watchers are being called,and only in the child after the fork. If whoever good citizen callingev_default_fork cheats and calls it in the wrong process, the forkhandlers will be invoked, too, of course.
 
  
 
 
  
Watcher-Specific Functions and Data Members
 
  
 
   
 
    ev_fork_init (ev_signal *, callback) 
   
 
   
 
    
Initialises and configures the fork watcher - it has no parameters of anykind. There is a ev_fork_set macro, but using it is utterly pointless,believe me.
 
   
 
  
 
  
 
 
  
ev_async - how to wake up another event loop
 
  
In general, you cannot use an ev_loop from multiple threads or otherasynchronous sources such as signal handlers (as opposed to multiple eventloops - those are of course safe to use in different threads).
 
  
Sometimes, however, you need to wake up another event loop you do notcontrol, for example because it belongs to another thread. This is whatev_async watchers do: as long as the ev_async watcher is active, youcan signal it by calling ev_async_send, which is thread- and signalsafe.
 
  
This functionality is very similar to ev_signal watchers, as signals,too, are asynchronous in nature, and signals, too, will be compressed(i.e. the number of callback invocations may be less than the number ofev_async_sent calls).
 
  
Unlike ev_signal watchers, ev_async works with any event loop, notjust the default loop.
 
  
 
 
  
Queueing
 
  
ev_async does not support queueing of data in any way. The reasonis that the author does not know of a simple (or any) algorithm for amultiple-writer-single-reader queue that works in all cases and doesn'tneed elaborate support such as pthreads.
 
  
That means that if you want to queue data, you have to provide your ownqueue. But at least I can tell you would implement locking around yourqueue:
 
  
 
   
 
    queueing from a signal handler context 
   
 
   
 
    
To implement race-free queueing, you simply add to the queue in the signalhandler but you block the signal handler in the watcher callback. Here is an example that does that forsome fictitiuous SIGUSR1 handler:
 
   
 
   
 
    
 static ev_async mysig;
 
   
 
   
 
    
 static void sigusr1_handler (void) { sometype data;
 
   
 
   
 
    
 // no locking etc. queue_put (data); ev_async_send (EV_DEFAULT_ &mysig); }
 
   
 
   
 
    
 static void mysig_cb (EV_P_ ev_async *w, int revents) { sometype data; sigset_t block, prev;
 
   
 
   
 
    
 sigemptyset (&block); sigaddset (&block, SIGUSR1); sigprocmask (SIG_BLOCK, &block, &prev);
 
   
 
   
 
    
 while (queue_get (&data)) process (data);
 
   
 
   
 
    
 if (sigismember (&prev, SIGUSR1) sigprocmask (SIG_UNBLOCK, &block, 0); }
 
   
 
   
 
    
(Note: pthreads in theory requires you to use pthread_setmaskinstead of sigprocmask when you use threads, but libev doesn't do iteither...).
 
   
 
   
 
    queueing from a thread context 
   
 
   
 
    
The strategy for threads is different, as you cannot (easily) blockthreads but you can easily preempt them, so to queue safely you need toemploy a traditional mutex lock, such as in this pthread example:
 
   
 
   
 
    
 static ev_async mysig; static pthread_mutex_t mymutex = PTHREAD_MUTEX_INITIALIZER;
 
   
 
   
 
    
 static void otherthread (void) { // only need to lock the actual queueing operation pthread_mutex_lock (&mymutex); queue_put (data); pthread_mutex_unlock (&mymutex);
 
   
 
   
 
    
 ev_async_send (EV_DEFAULT_ &mysig); }
 
   
 
   
 
    
 static void mysig_cb (EV_P_ ev_async *w, int revents) { pthread_mutex_lock (&mymutex);
 
   
 
   
 
    
 while (queue_get (&data)) process (data);
 
   
 
   
 
    
 pthread_mutex_unlock (&mymutex); }
 
   
 
  
 
  
 
 
  
Watcher-Specific Functions and Data Members
 
  
 
   
 
    ev_async_init (ev_async *, callback) 
   
 
   
 
    
Initialises and configures the async watcher - it has no parameters of anykind. There is a ev_asynd_set macro, but using it is utterly pointless,believe me.
 
   
 
   
 
    ev_async_send (loop, ev_async *) 
   
 
   
 
    
Sends/signals/activates the given ev_async watcher, that is, feedsan EV_ASYNC event on the watcher into the event loop. Unlikeev_feed_event, this call is safe to do in other threads, signal orsimilar contexts (see the dicusssion of EV_ATOMIC_T in the embeddingsection below on what exactly this means).
 
   
 
   
 
    
This call incurs the overhead of a syscall only once per loop iteration,so while the overhead might be noticable, it doesn't apply to repeatedcalls to ev_async_send.
 
   
 
   
 
    bool = ev_async_pending (ev_async *) 
   
 
   
 
    
Returns a non-zero value when ev_async_send has been called on thewatcher but the event has not yet been processed (or even noted) by theevent loop.
 
   
 
   
 
    
ev_async_send sets a flag in the watcher and wakes up the loop. Whenthe loop iterates next and checks for the watcher to have become active,it will reset the flag again. ev_async_pending can be used to veryquickly check wether invoking the loop might be a good idea.
 
   
 
   
 
    
Not that this does not check wether the watcher itself is pending, onlywether it has been requested to make this watcher pending.
 
   
 
  
 
  
 
 
  
 
  
OTHER FUNCTIONS
 
  
There are some other functions of possible interest. Described. Here. Now.
 
  
 
   
 
    ev_once (loop, int fd, int events, ev_tstamp timeout, callback) 
   
 
   
 
    
This function combines a simple timer and an I/O watcher, calls yourcallback on whichever event happens first and automatically stop bothwatchers. This is useful if you want to wait for a single event on an fdor timeout without having to allocate/configure/start/stop/free one ormore watchers yourself.
 
   
 
   
 
    
If fd is less than 0, then no I/O watcher will be started and eventsis being ignored. Otherwise, an ev_io watcher for the given fd andevents set will be craeted and started.
 
   
 
   
 
    
If timeout is less than 0, then no timeout watcher will bestarted. Otherwise an ev_timer watcher with after = timeout (andrepeat = 0) will be started. While 0 is a valid timeout, it is ofdubious value.
 
   
 
   
 
    
The callback has the type void (*cb)(int revents, void *arg) and getspassed an revents set like normal event callbacks (a combination ofEV_ERROR, EV_READ, EV_WRITE or EV_TIMEOUT) and the argvalue passed to ev_once:
 
   
 
   
 
    
 static void stdin_ready (int revents, void *arg) { if (revents & EV_TIMEOUT) /* doh, nothing entered */; else if (revents & EV_READ) /* stdin might have data for us, joy! */; }
 
   
 
   
 
    
 ev_once (STDIN_FILENO, EV_READ, 10., stdin_ready, 0);
 
   
 
   
 
    ev_feed_event (ev_loop *, watcher *, int revents) 
   
 
   
 
    
Feeds the given event set into the event loop, as if the specified eventhad happened for the specified watcher (which must be a pointer to aninitialised but not necessarily started event watcher).
 
   
 
   
 
    ev_feed_fd_event (ev_loop *, int fd, int revents) 
   
 
   
 
    
Feed an event on the given fd, as if a file descriptor backend detectedthe given events it.
 
   
 
   
 
    ev_feed_signal_event (ev_loop *loop, int signum) 
   
 
   
 
    
Feed an event as if the given signal occured (loop must be the defaultloop!).
 
   
 
  
 
  
 
 
  
 
  
LIBEVENT EMULATION
 
  
Libev offers a compatibility emulation layer for libevent. It cannotemulate the internals of libevent, so here are some usage hints:
 
  
     
   
  • Use it by including <event.h>, as usual.
    •  
   
  • The following members are fully supported: ev_base, ev_callback,ev_arg, ev_fd, ev_res, ev_events.
    •  
   
  • Avoid using ev_flags and the EVLIST_*-macros, while it ismaintained by libev, it does not work exactly the same way as in libevent (considerit a private API).
    •  
   
  • Priorities are not currently supported. Initialising prioritieswill fail and all watchers will have the same priority, even though thereis an ev_pri field.
    •  
   
  • In libevent, the last base created gets the signals, in libev, thefirst base created (== the default loop) gets the signals.
    •  
   
  • Other members are not supported.
    •  
   
  • The libev emulation is not ABI compatible to libevent, you needto use the libev header file and library.
    •  
  
 
  
 
 
  
 
  
C++ SUPPORT
 
  
Libev comes with some simplistic wrapper classes for C++ that mainly allowyou to use some convinience methods to start/stop watchers and also changethe callback model to a model using method callbacks on objects.
 
  
To use it,
 
  
 #include <ev++.h>
 
  
This automatically includes ev.h and puts all of its definitions (manyof them macros) into the global namespace. All C++ specific things areput into the ev namespace. It should support all the same embeddingoptions as ev.h, most notably EV_MULTIPLICITY.
 
  
Care has been taken to keep the overhead low. The only data member the C++classes add (compared to plain C-style watchers) is the event loop pointerthat the watcher is associated with (or no additional members at all ifyou disable EV_MULTIPLICITY when embedding libev).
 
  
Currently, functions, and static and non-static member functions can beused as callbacks. Other types should be easy to add as long as they onlyneed one additional pointer for context. If you need support for othertypes of functors please contact the author (preferably after implementingit).
 
  
Here is a list of things available in the ev namespace:
 
  
 
   
 
    ev::READ, ev::WRITE etc. 
   
 
   
 
    
These are just enum values with the same values as the EV_READ etc.macros from ev.h.
 
   
 
   
 
    ev::tstamp, ev::now 
   
 
   
 
    
Aliases to the same types/functions as with the ev_ prefix.
 
   
 
   
 
    ev::io, ev::timer, ev::periodic, ev::idle, ev::sig etc. 
   
 
   
 
    
For each ev_TYPE watcher in ev.h there is a corresponding class ofthe same name in the ev namespace, with the exception of ev_signalwhich is called ev::sig to avoid clashes with the signal macrodefines by many implementations.
 
   
 
   
 
    
All of those classes have these methods:
 
   
 
  
 
  
 
   
 
    ev::TYPE::TYPE () 
   
 
   
 
    ev::TYPE::TYPE (struct ev_loop *) 
   
 
   
 
    ev::TYPE::~TYPE 
   
 
   
 
    
The constructor (optionally) takes an event loop to associate the watcherwith. If it is omitted, it will use EV_DEFAULT.
 
   
 
   
 
    
The constructor calls ev_init for you, which means you have to call theset method before starting it.
 
   
 
   
 
    
It will not set a callback, however: You have to call the templated setmethod to set a callback before you can start the watcher.
 
   
 
   
 
    
(The reason why you have to use a method is a limitation in C++ which doesnot allow explicit template arguments for constructors).
 
   
 
   
 
    
The destructor automatically stops the watcher if it is active.
 
   
 
   
 
    w->set<class, &class::method> (object *) 
   
 
   
 
    
This method sets the callback method to call. The method has to have asignature of void (*)(ev_TYPE &, int), it receives the watcher asfirst argument and the revents as second. The object must be given asparameter and is stored in the data member of the watcher.
 
   
 
   
 
    
This method synthesizes efficient thunking code to call your method fromthe C callback that libev requires. If your compiler can inline yourcallback (i.e. it is visible to it at the place of the set call andyour compiler is good :), then the method will be fully inlined into thethunking function, making it as fast as a direct C callback.
 
   
 
   
 
    
Example: simple class declaration and watcher initialisation
 
   
 
   
 
    
 struct myclass { void io_cb (ev::io &w, int revents) { } }
 
   
 
   
 
    
 myclass obj; ev::io iow; iow.set <myclass, &myclass::io_cb> (&obj);
 
   
 
   
 
    w->set<function> (void *data = 0) 
   
 
   
 
    
Also sets a callback, but uses a static method or plain function ascallback. The optional data argument will be stored in the watcher'sdata member and is free for you to use.
 
   
 
   
 
    
The prototype of the function must be void (*)(ev::TYPE &w, int).
 
   
 
   
 
    
See the method-set above for more details.
 
   
 
   
 
    
Example:
 
   
 
   
 
    
 static void io_cb (ev::io &w, int revents) { } iow.set <io_cb> ();
 
   
 
   
 
    w->set (struct ev_loop *) 
   
 
   
 
    
Associates a different struct ev_loop with this watcher. You can onlydo this when the watcher is inactive (and not pending either).
 
   
 
   
 
    w->set ([args]) 
   
 
   
 
    
Basically the same as ev_TYPE_set, with the same args. Must becalled at least once. Unlike the C counterpart, an active watcher getsautomatically stopped and restarted when reconfiguring it with thismethod.
 
   
 
   
 
    w->start () 
   
 
   
 
    
Starts the watcher. Note that there is no loop argument, as theconstructor already stores the event loop.
 
   
 
   
 
    w->stop () 
   
 
   
 
    
Stops the watcher if it is active. Again, no loop argument.
 
   
 
   
 
    w->again () (ev::timer, ev::periodic only) 
   
 
   
 
    
For ev::timer and ev::periodic, this invokes the correspondingev_TYPE_again function.
 
   
 
   
 
    w->sweep () (ev::embed only) 
   
 
   
 
    
Invokes ev_embed_sweep.
 
   
 
   
 
    w->update () (ev::stat only) 
   
 
   
 
    
Invokes ev_stat_stat.
 
   
 
  
 
  
Example: Define a class with an IO and idle watcher, start one of them inthe constructor.
 
  
 class myclass { ev::io io; void io_cb (ev::io &w, int revents); ev:idle idle void idle_cb (ev::idle &w, int revents);
 
  
 myclass (int fd) { io .set <myclass, &myclass::io_cb > (this); idle.set <myclass, &myclass::idle_cb> (this);
 
  
 io.start (fd, ev::READ); } };
 
  
 
 
  
 
  
OTHER LANGUAGE BINDINGS
 
  
Libev does not offer other language bindings itself, but bindings for anumbe rof languages exist in the form of third-party packages. If you knowany interesting language binding in addition to the ones listed here, dropme a note.
 
  
 
   
 
    Perl 
   
 
   
 
    
The EV module implements the full libev API and is actually used to testlibev. EV is developed together with libev. Apart from the EV core module,there are additional modules that implement libev-compatible interfacesto libadns (EV::ADNS), Net::SNMP (Net::SNMP::EV) and thelibglib event core (Glib::EV and EV::Glib).
 
   
 
   
 
    
It can be found and installed via CPAN, its homepage is found athttp://software.schmorp.de/pkg/EV.
 
   
 
   
 
    Ruby 
   
 
   
 
    
Tony Arcieri has written a ruby extension that offers access to a subsetof the libev API and adds filehandle abstractions, asynchronous DNS andmore on top of it. It can be found via gem servers. Its homepage is athttp://rev.rubyforge.org/.
 
   
 
   
 
    D 
   
 
   
 
    
Leandro Lucarella has written a D language binding (ev.d) for libev, tobe found at http://git.llucax.com.ar/.
 
   
 
  
 
  
 
 
  
 
  
MACRO MAGIC
 
  
Libev can be compiled with a variety of options, the most fundamantalof which is EV_MULTIPLICITY. This option determines whether (most)functions and callbacks have an initial struct ev_loop * argument.
 
  
To make it easier to write programs that cope with either variant, thefollowing macros are defined:
 
  
 
   
 
    EV_A, EV_A_ 
   
 
   
 
    
This provides the loop argument for functions, if one is required (``evloop argument''). The EV_A form is used when this is the sole argument,EV_A_ is used when other arguments are following. Example:
 
   
 
   
 
    
 ev_unref (EV_A); ev_timer_add (EV_A_ watcher); ev_loop (EV_A_ 0);
 
   
 
   
 
    
It assumes the variable loop of type struct ev_loop * is in scope,which is often provided by the following macro.
 
   
 
   
 
    EV_P, EV_P_ 
   
 
   
 
    
This provides the loop parameter for functions, if one is required (``evloop parameter''). The EV_P form is used when this is the sole parameter,EV_P_ is used when other parameters are following. Example:
 
   
 
   
 
    
 // this is how ev_unref is being declared static void ev_unref (EV_P);
 
   
 
   
 
    
 // this is how you can declare your typical callback static void cb (EV_P_ ev_timer *w, int revents)
 
   
 
   
 
    
It declares a parameter loop of type struct ev_loop *, quitesuitable for use with EV_A.
 
   
 
   
 
    EV_DEFAULT, EV_DEFAULT_ 
   
 
   
 
    
Similar to the other two macros, this gives you the value of the defaultloop, if multiple loops are supported (``ev loop default'').
 
   
 
   
 
    EV_DEFAULT_UC, EV_DEFAULT_UC_ 
   
 
   
 
    
Usage identical to EV_DEFAULT and EV_DEFAULT_, but requires that thedefault loop has been initialised (UC == unchecked). Their behaviouris undefined when the default loop has not been initialised by a previousexecution of EV_DEFAULT, EV_DEFAULT_ or ev_default_init (...).
 
   
 
   
 
    
It is often prudent to use EV_DEFAULT when initialising the firstwatcher in a function but use EV_DEFAULT_UC afterwards.
 
   
 
  
 
  
Example: Declare and initialise a check watcher, utilising the abovemacros so it will work regardless of whether multiple loops are supportedor not.
 
  
 static void check_cb (EV_P_ ev_timer *w, int revents) { ev_check_stop (EV_A_ w); }
 
  
 ev_check check; ev_check_init (&check, check_cb); ev_check_start (EV_DEFAULT_ &check); ev_loop (EV_DEFAULT_ 0);
 
  
 
 
  
 
  
EMBEDDING
 
  
Libev can (and often is) directly embedded into hostapplications. Examples of applications that embed it include the DeliantraGame Server, the EV perl module, the GNU Virtual Private Ethernet (gvpe)and rxvt-unicode.
 
  
The goal is to enable you to just copy the necessary files into yoursource directory without having to change even a single line in them, soyou can easily upgrade by simply copying (or having a checked-out copy oflibev somewhere in your source tree).
 
  
 
 
  
FILESETS
 
  
Depending on what features you need you need to include one or more sets of filesin your app.
 
  
 
 
  
CORE EVENT LOOP
 
  
To include only the libev core (all the ev_* functions), with manualconfiguration (no autoconf):
 
  
 #define EV_STANDALONE 1 #include "ev.c"
 
  
This will automatically include ev.h, too, and should be done in asingle C source file only to provide the function implementations. To useit, do the same for ev.h in all files wishing to use this API (bestdone by writing a wrapper around ev.h that you can include instead andwhere you can put other configuration options):
 
  
 #define EV_STANDALONE 1 #include "ev.h"
 
  
Both header files and implementation files can be compiled with a C++compiler (at least, thats a stated goal, and breakage will be treatedas a bug).
 
  
You need the following files in your source tree, or in a directoryin your include path (e.g. in libev/ when using -Ilibev):
 
  
 ev.h ev.c ev_vars.h ev_wrap.h
 
  
 ev_win32.c required on win32 platforms only
 
  
 ev_select.c only when select backend is enabled (which is enabled by default) ev_poll.c only when poll backend is enabled (disabled by default) ev_epoll.c only when the epoll backend is enabled (disabled by default) ev_kqueue.c only when the kqueue backend is enabled (disabled by default) ev_port.c only when the solaris port backend is enabled (disabled by default)
 
  
ev.c includes the backend files directly when enabled, so you only needto compile this single file.
 
  
 
 
  
LIBEVENT COMPATIBILITY API
 
  
To include the libevent compatibility API, also include:
 
  
 #include "event.c"
 
  
in the file including ev.c, and:
 
  
 #include "event.h"
 
  
in the files that want to use the libevent API. This also includes ev.h.
 
  
You need the following additional files for this:
 
  
 event.h event.c
 
  
 
 
  
AUTOCONF SUPPORT
 
  
Instead of using EV_STANDALONE=1 and providing your config inwhatever way you want, you can also m4_include([libev.m4]) in yourconfigure.ac and leave EV_STANDALONE undefined. ev.c will theninclude config.h and configure itself accordingly.
 
  
For this of course you need the m4 file:
 
  
 libev.m4
 
  
 
 
  
PREPROCESSOR SYMBOLS/MACROS
 
  
Libev can be configured via a variety of preprocessor symbols you have todefine before including any of its files. The default in the absense ofautoconf is noted for every option.
 
  
 
   
 
    EV_STANDALONE 
   
 
   
 
    
Must always be 1 if you do not use autoconf configuration, whichkeeps libev from including config.h, and it also defines dummyimplementations for some libevent functions (such as logging, which is notsupported). It will also not define any of the structs usually found inevent.h that are not directly supported by the libev core alone.
 
   
 
   
 
    EV_USE_MONOTONIC 
   
 
   
 
    
If defined to be 1, libev will try to detect the availability of themonotonic clock option at both compiletime and runtime. Otherwise no useof the monotonic clock option will be attempted. If you enable this, youusually have to link against librt or something similar. Enabling it whenthe functionality isn't available is safe, though, although you haveto make sure you link against any libraries where the clock_gettimefunction is hiding in (often -lrt).
 
   
 
   
 
    EV_USE_REALTIME 
   
 
   
 
    
If defined to be 1, libev will try to detect the availability of therealtime clock option at compiletime (and assume its availability atruntime if successful). Otherwise no use of the realtime clock option willbe attempted. This effectively replaces gettimeofday by clock_get(CLOCK_REALTIME, ...) and will not normally affect correctness. See thenote about libraries in the description of EV_USE_MONOTONIC, though.
 
   
 
   
 
    EV_USE_NANOSLEEP 
   
 
   
 
    
If defined to be 1, libev will assume that nanosleep () is availableand will use it for delays. Otherwise it will use select ().
 
   
 
   
 
    EV_USE_EVENTFD 
   
 
   
 
    
If defined to be 1, then libev will assume that eventfd () isavailable and will probe for kernel support at runtime. This will improveev_signal and ev_async performance and reduce resource consumption.If undefined, it will be enabled if the headers indicate GNU/Linux + Glibc2.7 or newer, otherwise disabled.
 
   
 
   
 
    EV_USE_SELECT 
   
 
   
 
    
If undefined or defined to be 1, libev will compile in support for theselect(2) backend. No attempt at autodetection will be done: if noother method takes over, select will be it. Otherwise the select backendwill not be compiled in.
 
   
 
   
 
    EV_SELECT_USE_FD_SET 
   
 
   
 
    
If defined to 1, then the select backend will use the system fd_setstructure. This is useful if libev doesn't compile due to a missingNFDBITS or fd_mask definition or it misguesses the bitset layout onexotic systems. This usually limits the range of file descriptors to somelow limit such as 1024 or might have other limitations (winsocket onlyallows 64 sockets). The FD_SETSIZE macro, set before compilation, mightinfluence the size of the fd_set used.
 
   
 
   
 
    EV_SELECT_IS_WINSOCKET 
   
 
   
 
    
When defined to 1, the select backend will assume thatselect/socket/connect etc. don't understand file descriptors butwants osf handles on win32 (this is the case when the select tobe used is the winsock select). This means that it will call_get_osfhandle on the fd to convert it to an OS handle. Otherwise,it is assumed that all these functions actually work on fds, evenon win32. Should not be defined on non-win32 platforms.
 
   
 
   
 
    EV_FD_TO_WIN32_HANDLE 
   
 
   
 
    
If EV_SELECT_IS_WINSOCKET is enabled, then libev needs a way to mapfile descriptors to socket handles. When not defining this symbol (thedefault), then libev will call _get_osfhandle, which is usuallycorrect. In some cases, programs use their own file descriptor management,in which case they can provide this function to map fds to socket handles.
 
   
 
   
 
    EV_USE_POLL 
   
 
   
 
    
If defined to be 1, libev will compile in support for the poll(2)backend. Otherwise it will be enabled on non-win32 platforms. Ittakes precedence over select.
 
   
 
   
 
    EV_USE_EPOLL 
   
 
   
 
    
If defined to be 1, libev will compile in support for the Linuxepoll(7) backend. Its availability will be detected at runtime,otherwise another method will be used as fallback. This is the preferredbackend for GNU/Linux systems. If undefined, it will be enabled if theheaders indicate GNU/Linux + Glibc 2.4 or newer, otherwise disabled.
 
   
 
   
 
    EV_USE_KQUEUE 
   
 
   
 
    
If defined to be 1, libev will compile in support for the BSD stylekqueue(2) backend. Its actual availability will be detected at runtime,otherwise another method will be used as fallback. This is the preferredbackend for BSD and BSD-like systems, although on most BSDs kqueue onlysupports some types of fds correctly (the only platform we found thatsupports ptys for example was NetBSD), so kqueue might be compiled in, butnot be used unless explicitly requested. The best way to use it is to findout whether kqueue supports your type of fd properly and use an embeddedkqueue loop.
 
   
 
   
 
    EV_USE_PORT 
   
 
   
 
    
If defined to be 1, libev will compile in support for the Solaris10 port style backend. Its availability will be detected at runtime,otherwise another method will be used as fallback. This is the preferredbackend for Solaris 10 systems.
 
   
 
   
 
    EV_USE_DEVPOLL 
   
 
   
 
    
reserved for future expansion, works like the USE symbols above.
 
   
 
   
 
    EV_USE_INOTIFY 
   
 
   
 
    
If defined to be 1, libev will compile in support for the Linux inotifyinterface to speed up ev_stat watchers. Its actual availability willbe detected at runtime. If undefined, it will be enabled if the headersindicate GNU/Linux + Glibc 2.4 or newer, otherwise disabled.
 
   
 
   
 
    EV_ATOMIC_T 
   
 
   
 
    
Libev requires an integer type (suitable for storing 0 or 1) whoseaccess is atomic with respect to other threads or signal contexts. No suchtype is easily found in the C language, so you can provide your own typethat you know is safe for your purposes. It is used both for signal handler ``locking''as well as for signal and thread safety in ev_async watchers.
 
   
 
   
 
    
In the absense of this define, libev will use sig_atomic_t volatile(from signal.h), which is usually good enough on most platforms.
 
   
 
   
 
    EV_H 
   
 
   
 
    
The name of the ev.h header file used to include it. The default ifundefined is "ev.h" in event.h, ev.c and ev++.h. This can beused to virtually rename the ev.h header file in case of conflicts.
 
   
 
   
 
    EV_CONFIG_H 
   
 
   
 
    
If EV_STANDALONE isn't 1, this variable can be used to overrideev.c's idea of where to find the config.h file, similarly toEV_H, above.
 
   
 
   
 
    EV_EVENT_H 
   
 
   
 
    
Similarly to EV_H, this macro can be used to override event.c's ideaof how the event.h header can be found, the default is "event.h".
 
   
 
   
 
    EV_PROTOTYPES 
   
 
   
 
    
If defined to be 0, then ev.h will not define any functionprototypes, but still define all the structs and other symbols. This isoccasionally useful if you want to provide your own wrapper functionsaround libev functions.
 
   
 
   
 
    EV_MULTIPLICITY 
   
 
   
 
    
If undefined or defined to 1, then all event-loop-specific functionswill have the struct ev_loop * as first argument, and you can createadditional independent event loops. Otherwise there will be no supportfor multiple event loops and there is no first event loop pointerargument. Instead, all functions act on the single default loop.
 
   
 
   
 
    EV_MINPRI 
   
 
   
 
    EV_MAXPRI 
   
 
   
 
    
The range of allowed priorities. EV_MINPRI must be smaller or equal toEV_MAXPRI, but otherwise there are no non-obvious limitations. You canprovide for more priorities by overriding those symbols (usually definedto be -2 and 2, respectively).
 
   
 
   
 
    
When doing priority-based operations, libev usually has to linearly searchall the priorities, so having many of them (hundreds) uses a lot of spaceand time, so using the defaults of five priorities (-2 .. +2) is usuallyfine.
 
   
 
   
 
    
If your embedding app does not need any priorities, defining these both to0 will save some memory and cpu.
 
   
 
   
 
    EV_PERIODIC_ENABLE 
   
 
   
 
    
If undefined or defined to be 1, then periodic timers are supported. Ifdefined to be 0, then they are not. Disabling them saves a few kB ofcode.
 
   
 
   
 
    EV_IDLE_ENABLE 
   
 
   
 
    
If undefined or defined to be 1, then idle watchers are supported. Ifdefined to be 0, then they are not. Disabling them saves a few kB ofcode.
 
   
 
   
 
    EV_EMBED_ENABLE 
   
 
   
 
    
If undefined or defined to be 1, then embed watchers are supported. Ifdefined to be 0, then they are not.
 
   
 
   
 
    EV_STAT_ENABLE 
   
 
   
 
    
If undefined or defined to be 1, then stat watchers are supported. Ifdefined to be 0, then they are not.
 
   
 
   
 
    EV_FORK_ENABLE 
   
 
   
 
    
If undefined or defined to be 1, then fork watchers are supported. Ifdefined to be 0, then they are not.
 
   
 
   
 
    EV_ASYNC_ENABLE 
   
 
   
 
    
If undefined or defined to be 1, then async watchers are supported. Ifdefined to be 0, then they are not.
 
   
 
   
 
    EV_MINIMAL 
   
 
   
 
    
If you need to shave off some kilobytes of code at the expense of somespeed, define this symbol to 1. Currently this is used to override someinlining decisions, saves roughly 30% codesize of amd64. It also selects amuch smaller 2-heap for timer management over the default 4-heap.
 
   
 
   
 
    EV_PID_HASHSIZE 
   
 
   
 
    
ev_child watchers use a small hash table to distribute workload bypid. The default size is 16 (or 1 with EV_MINIMAL), usually morethan enough. If you need to manage thousands of children you might want toincrease this value (must be a power of two).
 
   
 
   
 
    EV_INOTIFY_HASHSIZE 
   
 
   
 
    
ev_stat watchers use a small hash table to distribute workload byinotify watch id. The default size is 16 (or 1 with EV_MINIMAL),usually more than enough. If you need to manage thousands of ev_statwatchers you might want to increase this value (must be a power oftwo).
 
   
 
   
 
    EV_USE_4HEAP 
   
 
   
 
    
Heaps are not very cache-efficient. To improve the cache-efficiency of thetimer and periodics heap, libev uses a 4-heap when this symbol is definedto 1. The 4-heap uses more complicated (longer) code but hasnoticably faster performance with many (thousands) of watchers.
 
   
 
   
 
    
The default is 1 unless EV_MINIMAL is set in which case it is 0(disabled).
 
   
 
   
 
    EV_HEAP_CACHE_AT 
   
 
   
 
    
Heaps are not very cache-efficient. To improve the cache-efficiency of thetimer and periodics heap, libev can cache the timestamp (at) withinthe heap structure (selected by defining EV_HEAP_CACHE_AT to 1),which uses 8-12 bytes more per watcher and a few hundred bytes more code,but avoids random read accesses on heap changes. This improves performancenoticably with with many (hundreds) of watchers.
 
   
 
   
 
    
The default is 1 unless EV_MINIMAL is set in which case it is 0(disabled).
 
   
 
   
 
    EV_VERIFY 
   
 
   
 
    
Controls how much internal verification (see ev_loop_verify ()) willbe done: If set to 0, no internal verification code will be compiledin. If set to 1, then verification code will be compiled in, but notcalled. If set to 2, then the internal verification code will becalled once per loop, which can slow down libev. If set to 3, then theverification code will be called very frequently, which will slow downlibev considerably.
 
   
 
   
 
    
The default is 1, unless EV_MINIMAL is set, in which case it will be0.
 
   
 
   
 
    EV_COMMON 
   
 
   
 
    
By default, all watchers have a void *data member. By redefiningthis macro to a something else you can include more and other types ofmembers. You have to define it each time you include one of the files,though, and it must be identical each time.
 
   
 
   
 
    
For example, the perl EV module uses something like this:
 
   
 
   
 
    
 #define EV_COMMON \ SV *self; /* contains this struct */ \ SV *cb_sv, *fh /* note no trailing ";" */
 
   
 
   
 
    EV_CB_DECLARE (type) 
   
 
   
 
    EV_CB_INVOKE (watcher, revents) 
   
 
   
 
    ev_set_cb (ev, cb) 
   
 
   
 
    
Can be used to change the callback member declaration in each watcher,and the way callbacks are invoked and set. Must expand to a struct memberdefinition and a statement, respectively. See the ev.h header file fortheir default definitions. One possible use for overriding these is toavoid the struct ev_loop * as first argument in all cases, or to usemethod calls instead of plain function calls in C++.
 
   
 
  
 
  
 
 
  
EXPORTED API SYMBOLS
 
  
If you need to re-export the API (e.g. via a dll) and you need a list ofexported symbols, you can use the provided Symbol.* files which listall public symbols, one per line:
 
  
 Symbols.ev for libev proper Symbols.event for the libevent emulation
 
  
This can also be used to rename all public symbols to avoid clashes withmultiple versions of libev linked together (which is obviously bad initself, but sometimes it is inconvinient to avoid this).
 
  
A sed command like this will create wrapper #define's that you need toinclude before including ev.h:
 
  
 <Symbols.ev sed -e "s/.*/#define & myprefix_&/" >wrap.h
 
  
This would create a file wrap.h which essentially looks like this:
 
  
 #define ev_backend myprefix_ev_backend #define ev_check_start myprefix_ev_check_start #define ev_check_stop myprefix_ev_check_stop ...
 
  
 
 
  
EXAMPLES
 
  
For a real-world example of a program the includes libevverbatim, you can have a look at the EV perl module(http://software.schmorp.de/pkg/EV.html). It has the libev files inthe libev/ subdirectory and includes them in the EV/EVAPI.h (publicinterface) and EV.xs (implementation) files. Only the EV.xs filewill be compiled. It is pretty complex because it provides its own headerfile.
 
  
The usage in rxvt-unicode is simpler. It has a ev_cpp.h header filethat everybody includes and which overrides some configure choices:
 
  
 #define EV_MINIMAL 1 #define EV_USE_POLL 0 #define EV_MULTIPLICITY 0 #define EV_PERIODIC_ENABLE 0 #define EV_STAT_ENABLE 0 #define EV_FORK_ENABLE 0 #define EV_CONFIG_H <config.h> #define EV_MINPRI 0 #define EV_MAXPRI 0
 
  
 #include "ev++.h"
 
  
And a ev_cpp.C implementation file that contains libev proper and is compiled:
 
  
 #include "ev_cpp.h" #include "ev.c"
 
  
 
 
  
 
  
THREADS AND COROUTINES
 
  
 
 
  
THREADS
 
  
Libev itself is completely threadsafe, but it uses no locking. Thismeans that you can use as many loops as you want in parallel, as long asonly one thread ever calls into one libev function with the same loopparameter.
 
  
Or put differently: calls with different loop parameters can be done inparallel from multiple threads, calls with the same loop parameter must bedone serially (but can be done from different threads, as long as only onethread ever is inside a call at any point in time, e.g. by using a mutexper loop).
 
  
If you want to know which design is best for your problem, then I cannothelp you but by giving some generic advice:
 
  
     
   
  • most applications have a main thread: use the default libev loopin that thread, or create a seperate thread running only the default loop. 
    This helps integrating other libraries or software modules that use libevthemselves and don't care/know about threading.
     
    •  
   
  • one loop per thread is usually a good model. 
    Doing this is almost never wrong, sometimes a better-performance modelexists, but it is always a good start.
     
    •  
   
  • other models exist, such as the leader/follower pattern, where oneloop is handed through multiple threads in a kind of round-robbin fashion. 
    Chosing a model is hard - look around, learn, know that usually you cna dobetter than you currently do :-)
     
    •  
   
  • often you need to talk to some other thread which blocks in theevent loop - ev_async watchers can be used to wake them up from otherthreads safely (or from signal contexts...).
    •  
  
 
  
 
 
  
COROUTINES
 
  
Libev is much more accomodating to coroutines (``cooperative threads''):libev fully supports nesting calls to it's functions from differentcoroutines (e.g. you can call ev_loop on the same loop from twodifferent coroutines and switch freely between both coroutines running theloop, as long as you don't confuse yourself). The only exception is thatyou must not do this from ev_periodic reschedule callbacks.
 
  
Care has been invested into making sure that libev does not keep localstate inside ev_loop, and other calls do not usually allow coroutineswitches.
 
  
 
 
  
 
  
COMPLEXITIES
 
  
In this section the complexities of (many of) the algorithms used insidelibev will be explained. For complexity discussions about backends see thedocumentation for ev_default_init.
 
  
All of the following are about amortised time: If an array needs to beextended, libev needs to realloc and move the whole array, but thishappens asymptotically never with higher number of elements, so O(1) mightmean it might do a lengthy realloc operation in rare cases, but on averageit is much faster and asymptotically approaches constant time.
 
  
 
   
 
    Starting and stopping timer/periodic watchers: O(log skipped_other_timers) 
   
 
   
 
    
This means that, when you have a watcher that triggers in one hour andthere are 100 watchers that would trigger before that then inserting willhave to skip roughly seven (ld 100) of these watchers.
 
   
 
   
 
    Changing timer/periodic watchers (by autorepeat or calling again): O(log skipped_other_timers) 
   
 
   
 
    
That means that changing a timer costs less than removing/adding themas only the relative motion in the event queue has to be paid for.
 
   
 
   
 
    Starting io/check/prepare/idle/signal/child/fork/async watchers: O(1) 
   
 
   
 
    
These just add the watcher into an array or at the head of a list.
 
   
 
   
 
    Stopping check/prepare/idle/fork/async watchers: O(1) 
   
 
   
 
    Stopping an io/signal/child watcher: O(number_of_watchers_for_this_(fd/signal/pid % EV_PID_HASHSIZE)) 
   
 
   
 
    
These watchers are stored in lists then need to be walked to find thecorrect watcher to remove. The lists are usually short (you don't usuallyhave many watchers waiting for the same fd or signal).
 
   
 
   
 
    Finding the next timer in each loop iteration: O(1) 
   
 
   
 
    
By virtue of using a binary or 4-heap, the next timer is always found at afixed position in the storage array.
 
   
 
   
 
    Each change on a file descriptor per loop iteration: O(number_of_watchers_for_this_fd) 
   
 
   
 
    
A change means an I/O watcher gets started or stopped, which requireslibev to recalculate its status (and possibly tell the kernel, dependingon backend and wether ev_io_set was used).
 
   
 
   
 
    Activating one watcher (putting it into the pending state): O(1) 
   
 
   
 
    Priority handling: O(number_of_priorities) 
   
 
   
 
    
Priorities are implemented by allocating some space for eachpriority. When doing priority-based operations, libev usually has tolinearly search all the priorities, but starting/stopping and activatingwatchers becomes O(1) w.r.t. priority handling.
 
   
 
   
 
    Sending an ev_async: O(1) 
   
 
   
 
    Processing ev_async_send: O(number_of_async_watchers) 
   
 
   
 
    Processing signals: O(max_signal_number) 
   
 
   
 
    
Sending involves a syscall iff there were no other ev_async_sendcalls in the current loop iteration. Checking for async and signal eventsinvolves iterating over all running async watchers or all signal numbers.
 
   
 
  
 
  
 
 
  
 
  
Win32 platform limitations and workarounds
 
  
Win32 doesn't support any of the standards (e.g. POSIX) that libevrequires, and its I/O model is fundamentally incompatible with the POSIXmodel. Libev still offers limited functionality on this platform inthe form of the EVBACKEND_SELECT backend, and only supports socketdescriptors. This only applies when using Win32 natively, not when usinge.g. cygwin.
 
  
Lifting these limitations would basically require the fullre-implementation of the I/O system. If you are into these kinds ofthings, then note that glib does exactly that for you in a very portableway (note also that glib is the slowest event library known to man).
 
  
There is no supported compilation method available on windows exceptembedding it into other applications.
 
  
Due to the many, low, and arbitrary limits on the win32 platform andthe abysmal performance of winsockets, using a large number of socketsis not recommended (and not reasonable). If your program needs to usemore than a hundred or so sockets, then likely it needs to use a totallydifferent implementation for windows, as libev offers the POSIX readinessnotification model, which cannot be implemented efficiently on windows(microsoft monopoly games).
 
  
 
   
 
    The winsocket select function 
   
 
   
 
    
The winsocket select function doesn't follow POSIX in that itrequires socket handles and not socket file descriptors (it isalso extremely buggy). This makes select very inefficient, and alsorequires a mapping from file descriptors to socket handles. See thediscussion of the EV_SELECT_USE_FD_SET, EV_SELECT_IS_WINSOCKET andEV_FD_TO_WIN32_HANDLE preprocessor symbols for more info.
 
   
 
   
 
    
The configuration for a ``naked'' win32 using the microsoft runtimelibraries and raw winsocket select is:
 
   
 
   
 
    
 #define EV_USE_SELECT 1 #define EV_SELECT_IS_WINSOCKET 1 /* forces EV_SELECT_USE_FD_SET, too */
 
   
 
   
 
    
Note that winsockets handling of fd sets is O(n), so you can easily get acomplexity in the O(n²) range when using win32.
 
   
 
   
 
    Limited number of file descriptors 
   
 
   
 
    
Windows has numerous arbitrary (and low) limits on things.
 
   
 
   
 
    
Early versions of winsocket's select only supported waiting for a maximumof 64 handles (probably owning to the fact that all windows kernelscan only wait for 64 things at the same time internally; microsoftrecommends spawning a chain of threads and wait for 63 handles and theprevious thread in each. Great).
 
   
 
   
 
    
Newer versions support more handles, but you need to define FD_SETSIZEto some high number (e.g. 2048) before compiling the winsocket selectcall (which might be in libev or elsewhere, for example, perl does its ownselect emulation on windows).
 
   
 
   
 
    
Another limit is the number of file descriptors in the microsoft runtimelibraries, which by default is 64 (there must be a hidden 64 fetishor something like this inside microsoft). You can increase this by calling_setmaxstdio, which can increase this limit to 2048 (anotherarbitrary limit), but is broken in many versions of the microsoft runtimelibraries.
 
   
 
   
 
    
This might get you to about 512 or 2048 sockets (depending onwindows version and/or the phase of the moon). To get more, you need towrap all I/O functions and provide your own fd management, but the cost ofcalling select (O(n²)) will likely make this unworkable.
 
   
 
  
 
  
 
 
  
 
  
PORTABILITY REQUIREMENTS
 
  
In addition to a working ISO-C implementation, libev relies on a fewadditional extensions:
 
  
 
   
 
    sig_atomic_t volatile must be thread-atomic as well 
   
 
   
 
    
The type sig_atomic_t volatile (or whatever is defined asEV_ATOMIC_T) must be atomic w.r.t. accesses from differentthreads. This is not part of the specification for sig_atomic_t, but isbelieved to be sufficiently portable.
 
   
 
   
 
    sigprocmask must work in a threaded environment 
   
 
   
 
    
Libev uses sigprocmask to temporarily block signals. This is notallowed in a threaded program (pthread_sigmask has to be used). Typicalpthread implementations will either allow sigprocmask in the ``mainthread'' or will block signals process-wide, both behaviours wouldbe compatible with libev. Interaction between sigprocmask andpthread_sigmask could complicate things, however.
 
   
 
   
 
    
The most portable way to handle signals is to block signals in all threadsexcept the initial one, and run the default loop in the initial thread aswell.
 
   
 
   
 
    long must be large enough for common memory allocation sizes 
   
 
   
 
    
To improve portability and simplify using libev, libev uses longinternally instead of size_t when allocating its data structures. Onnon-POSIX systems (Microsoft...) this might be unexpectedly low, butis still at least 31 bits everywhere, which is enough for hundreds ofmillions of watchers.
 
   
 
   
 
    double must hold a time value in seconds with enough accuracy 
   
 
   
 
    
The type double is used to represent timestamps. It is required tohave at least 51 bits of mantissa (and 9 bits of exponent), which is goodenough for at least into the year 4000. This requirement is fulfilled byimplementations implementing IEEE 754 (basically all existing ones).
 
   
 
  
 
  
If you know of other additional requirements drop me a note.
 
  
 
 
  
 
  
COMPILER WARNINGS
 
  
Depending on your compiler and compiler settings, you might get no or alot of warnings when compiling libev code. Some people are apparentlyscared by this.
 
  
However, these are unavoidable for many reasons. For one, each compilerhas different warnings, and each user has different tastes regardingwarning options. ``Warn-free'' code therefore cannot be a goal except whentargetting a specific compiler and compiler-version.
 
  
Another reason is that some compiler warnings require elaborateworkarounds, or other changes to the code that make it less clear and lessmaintainable.
 
  
And of course, some compiler warnings are just plain stupid, or simplywrong (because they don't actually warn about the cindition their messageseems to warn about).
 
  
While libev is written to generate as few warnings as possible,``warn-free'' code is not a goal, and it is recommended not to build libevwith any compiler warnings enabled unless you are prepared to cope withthem (e.g. by ignoring them). Remember that warnings are just that:warnings, not errors, or proof of bugs.
 
  
 
 
  
 
  
VALGRIND
 
  
Valgrind has a special section here because it is a popular tool that ishighly useful, but valgrind reports are very hard to interpret.
 
  
If you think you found a bug (memory leak, uninitialised data access etc.)in libev, then check twice: If valgrind reports something like:
 
  
 ==2274== definitely lost: 0 bytes in 0 blocks. ==2274== possibly lost: 0 bytes in 0 blocks. ==2274== still reachable: 256 bytes in 1 blocks.
 
  
then there is no memory leak. Similarly, under some circumstances,valgrind might report kernel bugs as if it were a bug in libev, or itmight be confused (it is a very good tool, but only a tool).
 
  
If you are unsure about something, feel free to contact the mailing listwith the full valgrind report and an explanation on why you think this isa bug in libev. However, don't be annoyed when you get a brisk ``this isno bug'' answer and take the chance of learning how to interpret valgrindproperly.
 
  
If you need, for some reason, empty reports from valgrind for your projectI suggest using suppression lists.
 
  
 
 
  
 
  
AUTHOR
 
  
Marc Lehmann <[email protected]>.


                            

                        

                    

                    
                    

                    
                    
                    

                

                

                    
                

            

        

    

    

        
你可能感兴趣的:(lib)

        

            

                
    
                    
  • Python数据分析与可视化实战指南
                        William数据分析
pythonpython数据
                        
    在数据驱动的时代，Python因其简洁的语法、强大的库生态系统以及活跃的社区，成为了数据分析与可视化的首选语言。本文将通过一个详细的案例，带领大家学习如何使用Python进行数据分析，并通过可视化来直观呈现分析结果。一、环境准备1.1安装必要库在开始数据分析和可视化之前，我们需要安装一些常用的库。主要包括pandas、numpy、matplotlib和seaborn等。这些库分别用于数据处理、数学
    
                    
    • 
                    
  • linux sdl windows.h,Windows下的SDL安装
                        奔跑吧linux内核
linuxsdlwindows.h
                        
    首先你要下载并安装SDL开发包。如果装在C盘下，路径为C:\SDL1.2.5如果在WINDOWS下。你可以按以下步骤：1.打开VC++，点击"Tools",Options2,点击directories选项3.选择"Includefiles"增加一个新的路径。"C:\SDL1.2.5\include"4，现在选择"Libaryfiles“增加"C:\SDL1.2.5\lib"现在你可以开始编写你的第
    
                    
    • 
                    
  • libyuv之linux编译
                        jaronho
Linuxlinux运维服务器
                        
    文章目录一、下载源码二、编译源码三、注意事项1、银河麒麟系统（aarch64）（1）解决armv8-a+dotprod+i8mm指令集支持问题（2）解决armv9-a+sve2指令集支持问题一、下载源码到GitHub网站下载https://github.com/lemenkov/libyuv源码，或者用直接用git克隆到本地，如：gitclonehttps://github.com/lemenko
    
                    
    • 
                    
  • nosql数据库技术与应用知识点
                        皆过客，揽星河
NoSQLnosql数据库大数据数据分析数据结构非关系型数据库
                        
    Nosql知识回顾大数据处理流程数据采集(flume、爬虫、传感器)数据存储(本门课程NoSQL所处的阶段)Hdfs、MongoDB、HBase等数据清洗(入仓)Hive等数据处理、分析(Spark、Flink等)数据可视化数据挖掘、机器学习应用(Python、SparkMLlib等)大数据时代存储的挑战(三高)高并发(同一时间很多人访问)高扩展(要求随时根据需求扩展存储)高效率(要求读写速度快)
    
                    
    • 
                    
  • Python开发常用的三方模块如下：
                        换个网名有点难
python开发语言
                        
    Python是一门功能强大的编程语言，拥有丰富的第三方库，这些库为开发者提供了极大的便利。以下是100个常用的Python库，涵盖了多个领域：1、NumPy，用于科学计算的基础库。2、Pandas，提供数据结构和数据分析工具。3、Matplotlib，一个绘图库。4、Scikit-learn，机器学习库。5、SciPy，用于数学、科学和工程的库。6、TensorFlow，由Google开发的开源机
    
                    
    • 
                    
  • SpringCloudAlibaba—Sentinel(限流)
                        菜鸟爪哇

                        
    前言：自己在学习过程的记录，借鉴别人文章，记录自己实现的步骤。借鉴文章：https://blog.csdn.net/u014494148/article/details/105484410Sentinel介绍Sentinel诞生于阿里巴巴，其主要目标是流量控制和服务熔断。Sentinel是通过限制并发线程的数量（即信号隔离）来减少不稳定资源的影响，而不是使用线程池，省去了线程切换的性能开销。当资源
    
                    
    • 
                    
  • Python实现TIFF 文件转换为 PNG 和 JPG 格式
                        sand&wich
python开发语言
                        
    在日常的图像处理工作中，可能会遇到需要将TIFF格式的图像转换为其他格式的情况，例如PNG和JPG。下面，本文将介绍如何使用Python和GDAL库实现这一功能。准备工作在开始之前，请确保已经安装了必要的库：GDAL（GeospatialDataAbstractionLibrary）可以使用以下命令安装GDAL：pipinstallgdal代码实现以下是一个将TIFF文件转换为PNG文件的示例代码
    
                    
    • 
                    
  • GenVisR 基因组数据可视化实战(三)
                        11的雾

                        
    3.genCov画每个突变位点附件的coverage，跟igv有点相似。这个操作起来很复杂，但是图还是挺有用的。可以考虑。由于我的referencegenomebuild是hg38BiocManager::install(c("TxDb.Hsapiens.UCSC.hg38.knownGene","BSgenome.Hsapiens.UCSC.hg38"))library(TxDb.Hsapien
    
                    
    • 
                    
  • 【Python】已解决：ModuleNotFoundError: No module named ‘PIL’
                        屿小夏
python开发语言
                        
    文章目录一、分析问题背景二、可能出错的原因三、错误代码示例四、正确代码示例五、注意事项已解决：ModuleNotFoundError:Nomodulenamed‘PIL’一、分析问题背景当你在Python环境中尝试导入PIL（PythonImagingLibrary）模块时，可能会遇到“ModuleNotFoundError:Nomodulenamed‘PIL’”的错误。这通常发生在尝试使用PIL
    
                    
    • 
                    
  • Ubuntu18.04 Docker部署Kinship(Django)项目过程
                        Dante617

                        
    1Docker的安装https://blog.csdn.net/weixin_41735055/article/details/1003551792下载镜像dockerpullprogramize/python3.6.8-dlib下载的镜像里包含python3.6.8和dlib19.17.03启动镜像dockerrun-it--namekinship-p7777:80-p3307:3306-p55
    
                    
    • 
                    
  • sublime个人设置
                        bawangtianzun
sublimetext编辑器
                        
    如何拥有jiangly蒋老师同款编译器(sublimec++配置竞赛向）_哔哩哔哩_bilibiliSublimeText4的安装教程（新手竞赛向）-知乎(zhihu.com)创建文件自动保存为c++打开SublimeText软件。转到"Tools"（工具）>"Developer"（开发者）>"NewPlugin"（新建插件）。在打开的新文件中，粘贴以下代码：importsublimeimport
    
                    
    • 
                    
  • python画图|同时输出二维和三维图
                        西猫雷婶
python开发语言
                        
    前面已经学习了如何输出二维图和三维图，部分文章详见下述链接：python画图|极坐标下的3Dsurface-CSDN博客python画图|垂线标记系列_如何用pyplot画垂直x轴的线-CSDN博客有时候也需要同时输出二位和三维图，因此有必要学习一下。【1】官网教程首先我们打开官网教程，链接如下。https://matplotlib.org/stable/gallery/mplot3d/mixed
    
                    
    • 
                    
  • 解决SDK Manager 中 没有 Support Library
                        木鱼wzh

                        
    1、直接修改SDK-MANAGER打开sdk-manager—->Tools—->options然后点击packages—->showobsoletepackages即可在最下面的Extras目录下找到推荐两个自己使用的镜像服务器：mirrors.neusoft.edu.cn端口80mirrors.dormforce.net端口802、去官网下载SupportLibrar点击这里进入官网进入百度云
    
                    
    • 
                    
  • python编写直方图和饼图
                        2301_80421078
python开发语言
                        
    1.直方图#直方图的绘制#语法格式：plt.hist(x,bins),其中x:数据集；bins:统计数据的分布区间importmatplotlib.pyplotaspltimportpandasaspd#导入文件excel=pd.read_excel('成绩.xlsx')#print(excel)#避免乱码plt.rcParams['font.sans-serif']=['SimHei']x=ex
    
                    
    • 
                    
  • pythonpandas函数详解_Python pandas常用函数详解
                        Senvn

                        
    本文研究的主要是pandas常用函数，具体介绍如下。1import语句importpandasaspdimportnumpyasnpimportmatplotlib.pyplotaspltimportdatetimeimportre2文件读取df=pd.read_csv(path='file.csv')参数：header=None用默认列名，0，1，2，3...names=['A','B','C'
    
                    
    • 
                    
  • python画出分子化学空间分布（UMAP）
                        Sakaiay
python
                        
    利用umap画出分子化学空间分布图安装pipinstallumap-learn下面是用一个数据集举的例子importtorchimportumapimportpandasaspdimportnumpyasnpimportmatplotlib.pyplotaspltimportseabornassnsfromsklearn.manifoldimportTSNEfromrdkit.Chemimport
    
                    
    • 
                    
  • Sentinel
                        眼泪落在琴弦
springcloudjavajava
                        
    Sentinel（服务熔断降级限流）1.引入spring-cloud-starter-alibaba-sentinel2.下载sentinel服务器3.配置application地址信息4.在控制台调整参数【默认所以流控设置保存在内存中，重启失效】5.想实时监控需每个微服务导入actuator，并配置application暴露所有端口6.自定义sentinel流控返回数据7.配置sentinel类
    
                    
    • 
                    
  • talib的python库安装
                        jesonwz
python开发语言
                        
    talib的python库安装反正用清华源装不上发现talib的指标好多，想着用用，结果在python里装不上，清华源里提示找不到。也难怪，这个库上网查了一下，最新一次更新是在2013年，太老了。废话不说，上我的解决办法。解决方法步骤（靠谱的）思路：既然在线装不上，就用离线的1.下载对应python版本的talib的whl版本安装文件，链接在这：https://blog.csdn.net/FL16
    
                    
    • 
                    
  • Makefile问答之 04 优化异常与警告设置
                        捕鲸叉
Linux使用Linux系统编程Makefilelinux
                        
    Makefile怎样指定优化选项，包括编译和链接优化，常用的选项有哪些？在Makefile中，你可以通过设置编译器和链接器的选项来指定优化选项。优化选项可以分为编译优化和链接优化，以下是如何在Makefile中指定这些选项，以及一些常用的选项。示例Makefile#编译器CC=gcc#编译选项CFLAGS=-Wall-O2#链接选项LDFLAGS=-O2#需要链接的库LDLIBS=#目标文件TAR
    
                    
    • 
                    
  • TA-Lib Python 库 Windows 64位安装包
                        黄桥壮Quinn

                        
    TA-LibPython库Windows64位安装包TA.rar项目地址:https://gitcode.com/open-source-toolkit/3ff39简介本仓库提供了一个适用于Windows64位系统的TA-LibPython库安装包。TA-Lib是一个广泛用于金融技术分析的库，支持多种技术指标的计算。资源文件文件名TA-Lib-0.4.29-cp312-win-amd64.whl描
    
                    
    • 
                    
  • python绘制等高线和等值面初步
                        bcbobo21cn
图形学和3Dpython开发语言MatplotlibNumPy等高线
                        
    importmatplotlib.pyplotaspltimportnumpyasnpx=np.linspace(-5,6,210)y=np.linspace(-5,6,210)x,y=np.meshgrid(x,y)z=(1-x/2+x**5+y**4)*np.exp(-x**2-y**2)plt.contour(x,y,z,levels=9,colors='black')plt.show()i
    
                    
    • 
                    
  • python模块TA_Lib文件whl下载地址汇总
                        国产bug零零柒
whlpythonlinuxwindows
                        
    序号项目名称下载地址1TA_Lib-0.4.28-cp312-cp312-win32.whl.zip点我下载2TA_Lib-0.4.28-cp38-cp38-win32.whl.zip点我下载3TA_Lib-0.4.28-cp312-cp312-win_amd64.whl.zip点我下载4TA_Lib-0.4.28-cp38-cp38-win_amd64.whl.zip点我下载5TA_Lib-0.
    
                    
    • 
                    
  • py获取系统缩放比例
                        xu-jssy
Python自动化脚本python前端
                        
    fromwin32.libimportwin32conimportwin32api,win32gui,win32printscaling=1.0defget_real_resolution():"""获取真实的分辨率"""hDC=win32gui.GetDC(0)wide=win32print.GetDeviceCaps(hDC,win32con.DESKTOPHORZRES)high=win32
    
                    
    • 
                    
  • python抓取网页内容401应该用哪个库_python3使用requests模块爬取页面内容入门
                        坂田月半

                        
    python的爬虫相关模块有很多，除了requests模块，再如urllib和pycurl以及tornado等。相比而言，requests模块是相对简单易上手的。通过文本，大家可以迅速学会使用python的requests模块爬取页码内容。1.Requests唯一的一个非转基因的PythonHTTP库，人类可以安全享用。官网：http://cn.python-requests.org/zh_CN/
    
                    
    • 
                    
  • python的request请求401_Python模拟HTTPS请求返回HTTP 401 unauthorized错误
                        weixin_39599372

                        
    Python模拟HTTPS请求返回HTTP401unauthorized错误开始是使用的httplib模块，代码如下：header={"Content-type":"application/json","Accept":"*/*"}params={‘source‘:‘en‘,‘target‘:‘es‘,‘text‘:match.group(1)}data=urllib.urlencode(para
    
                    
    • 
                    
  • python使用MD5
                        18.程序员
哈希算法算法
                        
    一、要使用Python进行MD5加密，可以使用Python标准库中的hashlib模块。二、案例importhashlibstring="Hello,World!"#要进行加密的字符串hash_object=hashlib.md5(string.encode())#将字符串编码并进行MD5加密hash_hex=hash_object.hexdigest()#获取加密后的十六进制字符串print(h
    
                    
    • 
                    
  • 【Python爬虫】百度百科词条内容
                        PokiFighting
数据处理python爬虫开发语言
                        
    词条内容我这里随便选取了一个链接，用的是FBI的词条importurllib.requestimporturllib.parsefromlxmlimportetreedefquery(url):headers={'user-agent':'Mozilla/5.0(WindowsNT6.1;Win64;x64)AppleWebKit/537.36(KHTML,likeGecko)Chrome/80.
    
                    
    • 
                    
  • Humanize 项目教程
                        尤嫒冰

                        
    Humanize项目教程humanizeAJSlibraryforaddinga“humantouch”todata.项目地址:https://gitcode.com/gh_mirrors/humani/humanize项目介绍Humanize是一个开源项目，旨在将机器生成的文本转换为更加自然、人性化的文本。该项目通过先进的算法和自然语言处理技术，使得AI生成的内容更加贴近人类的表达方式，从而提高
    
                    
    • 
                    
  • python下载pandas库镜像_下载pandas库
                        weixin_39791152

                        
    背景交代：在下载matplotlib库时，我已经将pip的下载源手动更改为清华的镜像，所以，如果有小伙伴在下载库遇到问题，如timeout，请先将下载源改为国内镜像，具体操作见我的另一篇文章：今天的主题是安装pandas库~首先，按田字格+R，打开cmd，输入：pipinstallpandas嗯，不出所料地报错了……主要原因：pip._vendor.urllib3.exceptions.ReadT
    
                    
    • 
                    
  • 锋哥写一套前后端分离Python权限系统 基于Django5+DRF+Vue3.2+Element Plus+Jwt 视频教程 ，帅呆了~~
                        java1234_小锋
Python权限系统django权限系统pythonweb权限系统djangoDRFVUE权限python
                        
    大家好，我是java1234_小锋老师，最近写了一套【前后端分离Python权限系统基于Django5+DRF+Vue3.2+ElementPlus+Jwt】视频教程，持续更新中，计划月底更新完，感谢支持。视频在线地址：打造前后端分离Python权限系统基于Django5+DRF+Vue3.2+ElementPlus+Jwt视频教程（火爆连载更新中..）_哔哩哔哩_bilibili项目介绍本课程采
    
                    
    • 
                                
  • jvm调优总结（从基本概念 到 深度优化）
                                    oloz
javajvmjdk虚拟机应用服务器
                                    
    JVM参数详解：http://www.cnblogs.com/redcreen/archive/2011/05/04/2037057.html 
 
  Java虚拟机中，数据类型可以分为两类：基本类型和引用类型。基本类型的变量保存原始值，即：他代表的值就是数值本身；而引用类型的变量保存引用值。“引用值”代表了某个对象的引用，而不是对象本身，对象本身存放在这个引用值所表示的地址的位置。 
    
                                
    • 
                                
  • 【Scala十六】Scala核心十：柯里化函数
                                    bit1129
scala
                                    
    本篇文章重点说明什么是函数柯里化，这个语法现象的背后动机是什么，有什么样的应用场景，以及与部分应用函数(Partial Applied Function)之间的联系   1. 什么是柯里化函数 
A way to write functions with multiple parameter lists. For instance
def f(x: Int)(y: Int) is a 
    
                                
    • 
                                
  • HashMap
                                    dalan_123
java
                                    
    HashMap在java中对很多人来说都是熟的；基于hash表的map接口的非同步实现。允许使用null和null键；同时不能保证元素的顺序；也就是从来都不保证其中的元素的顺序恒久不变。 
1、数据结构 
    在java中，最基本的数据结构无外乎：数组 和 引用（指针），所有的数据结构都可以用这两个来构造，HashMap也不例外，归根到底HashMap就是一个链表散列的数据
    
                                
    • 
                                
  • Java Swing如何实时刷新JTextArea，以显示刚才加append的内容
                                    周凡杨
java更新swingJTextArea
                                    
    在代码中执行完textArea.append("message")后，如果你想让这个更新立刻显示在界面上而不是等swing的主线程返回后刷新，我们一般会在该语句后调用textArea.invalidate()和textArea.repaint()。

问题是这个方法并不能有任何效果，textArea的内容没有任何变化，这或许是swing的一个bug，有一个笨拙的办法可以实现
    
                                
    • 
                                
  • servlet或struts的Action处理ajax请求
                                    g21121
servlet
                                    
    其实处理ajax的请求非常简单，直接看代码就行了： 
		//如果用的是struts
		//HttpServletResponse response = ServletActionContext.getResponse();
		// 设置输出为文字流
		response.setContentType("text/plain");
		// 设置字符集
		res
    
                                
    • 
                                
  • FineReport的公式编辑框的语法简介
                                    老A不折腾
finereport公式总结
                                    
    FINEREPORT用到公式的地方非常多，单元格（以=开头的便被解析为公式），条件显示，数据字典，报表填报属性值定义，图表标题，轴定义，页眉页脚，甚至单元格的其他属性中的鼠标悬浮提示内容都可以写公式。 
简单的说下自己感觉的公式要注意的几个地方： 
  
1.if语句语法刚接触感觉比较奇怪，if(条件式子,值1,值2)，if可以嵌套，if(条件式子1，值1，if(条件式子2，值2，值3)
    
                                
    • 
                                
  • linux mysql 数据库乱码的解决办法
                                    墙头上一根草
linuxmysql数据库乱码
                                    
    linux 上mysql数据库区分大小写的配置 
lower_case_table_names=1 1-不区分大小写 0-区分大小写 
  
修改/etc/my.cnf 具体的修改内容如下: 
  
[client] 
default-character-set=utf8 
  
[mysqld] 
datadir=/var/lib/mysql 
socket=/va
    
                                
    • 
                                
  • 我的spring学习笔记6-ApplicationContext实例化的参数兼容思想
                                    aijuans
Spring 3
                                    
    ApplicationContext能读取多个Bean定义文件，方法是： 
 
 
ApplicationContext appContext = new ClassPathXmlApplicationContext（

new String[]｛“bean-config1.xml”，“bean-config2.xml”，“bean-config3.xml”，“bean-config4.xml
    
                                
    • 
                                
  • mysql 基准测试之sysbench
                                    annan211
基准测试mysql基准测试MySQL测试sysbench
                                    
    1 执行如下命令，安装sysbench-0.5： 
 tar xzvf sysbench-0.5.tar.gz  
 cd sysbench-0.5  
 chmod +x autogen.sh  
 ./autogen.sh  
 ./configure --with-mysql --with-mysql-includes=/usr/local/mysql
    
                                
    • 
                                
  • sql的复杂查询使用案列与技巧
                                    百合不是茶
oraclesql函数数据分页合并查询
                                    
      
本片博客使用的数据库表是oracle中的scott用户表; 
  
   
    -------------------  自然连接查询 
          查询 smith 的上司(两种方法) 
&
    
                                
    • 
                                
  • 深入学习Thread类
                                    bijian1013
javathread多线程java多线程
                                    
    一．             线程的名字 
下面来看一下Thread类的name属性，它的类型是String。它其实就是线程的名字。在Thread类中，有String getName()和void setName(String)两个方法用来设置和获取这个属性的值。 
同时，Thr
    
                                
    • 
                                
  • JSON串转换成Map以及如何转换到对应的数据类型
                                    bijian1013
javafastjsonnet.sf.json
                                    
            在实际开发中，难免会碰到JSON串转换成Map的情况，下面来看看这方面的实例。另外，由于fastjson只支持JDK1.5及以上版本，因此在JDK1.4的项目中可以采用net.sf.json来处理。 
一.fastjson实例 
JsonUtil.java 
package com.study;

impor
    
                                
    • 
                                
  • 【RPC框架HttpInvoker一】HttpInvoker：Spring自带RPC框架
                                    bit1129
spring
                                    
    HttpInvoker是Spring原生的RPC调用框架，HttpInvoker同Burlap和Hessian一样，提供了一致的服务Exporter以及客户端的服务代理工厂Bean，这篇文章主要是复制粘贴了Hessian与Spring集成一文，【RPC框架Hessian四】Hessian与Spring集成 
  在
【RPC框架Hessian二】Hessian 对象序列化和反序列化一文中
    
                                
    • 
                                
  • 【Mahout二】基于Mahout CBayes算法的20newsgroup的脚本分析
                                    bit1129
Mahout
                                    
    #!/bin/bash
#
# Licensed to the Apache Software Foundation (ASF) under one or more
# contributor license agreements.  See the NOTICE file distributed with
# this work for additional information re
    
                                
    • 
                                
  • nginx三种获取用户真实ip的方法
                                    ronin47

                                    
    随着nginx的迅速崛起，越来越多公司将apache更换成nginx. 同时也越来越多人使用nginx作为负载均衡, 并且代理前面可能还加上了CDN加速，但是随之也遇到一个问题：nginx如何获取用户的真实IP地址,如果后端是apache,请跳转到<apache获取用户真实IP地址>，如果是后端真实服务器是nginx，那么继续往下看。 
实例环境： 用户IP 120.22.11.11 
    
                                
    • 
                                
  • java-判断二叉树是不是平衡
                                    bylijinnan
java
                                    
    参考了 
http://zhedahht.blog.163.com/blog/static/25411174201142733927831/ 
但是用java来实现有一个问题。 
由于Java无法像C那样“传递参数的地址，函数返回时能得到参数的值”，唯有新建一个辅助类：AuxClass 
 
 

import ljn.help.*;
public class BalancedBTree {

    
                                
    • 
                                
  • BeanUtils.copyProperties VS PropertyUtils.copyProperties
                                    诸葛不亮
PropertyUtilsBeanUtils
                                    
     BeanUtils.copyProperties VS  PropertyUtils.copyProperties  
作为两个bean属性copy的工具类，他们被广泛使用，同时也很容易误用，给人造成困然；比如：昨天发现同事在使用BeanUtils.copyProperties copy有integer类型属性的bean时，没有考虑到会将null转换为0，而后面的业
    
                                
    • 
                                
  • [金融与信息安全]最简单的数据结构最安全
                                    comsci
数据结构
                                    
     
 
      现在最流行的数据库的数据存储文件都具有复杂的文件头格式，用操作系统的记事本软件是无法正常浏览的，这样的情况会有什么问题呢？ 
 
       从信息安全的角度来看，如果我们数据库系统仅仅把这种格式的数据文件做异地备份，如果相同版本的所有数据库管理系统都同时被攻击，那么
    
                                
    • 
                                
  • vi区段删除
                                    Cwind
linuxvi区段删除
                                    
    区段删除是编辑和分析一些冗长的配置文件或日志文件时比较常用的操作。简记下vi区段删除要点备忘。 
  
vi概述  
  
引文中并未将末行模式单独列为一种模式。单不单列并不重要，能区分命令模式与末行模式即可。 
  
vi区段删除步骤： 
1. 在末行模式下使用:set nu显示行号 
非必须，随光标移动vi右下角也会显示行号，能够正确找到并记录删除开始行
    
                                
    • 
                                
  • 清除tomcat缓存的方法总结
                                    dashuaifu
tomcat缓存
                                    
    用tomcat容器，大家可能会发现这样的问题，修改jsp文件后，但用IE打开 依然是以前的Jsp的页面。 
出现这种现象的原因主要是tomcat缓存的原因。 
解决办法如下: 
在jsp文件头加上 
<meta http-equiv="Expires" content="0"> <meta http-equiv="kiben&qu
    
                                
    • 
                                
  • 不要盲目的在项目中使用LESS CSS
                                    dcj3sjt126com
Webless
                                    
    　如果你还不知道LESS CSS是什么东西，可以看一下这篇文章，是我一朋友写给新人看的《CSS——LESS》 
　　不可否认，LESS CSS是个强大的工具，它弥补了css没有变量、无法运算等一些“先天缺陷”，但它似乎给我一种错觉，就是为了功能而实现功能。 
　　比如它的引用功能    
?        
.rounded_corners{   
    
    
                                
    • 
                                
  • [入门]更上一层楼
                                    dcj3sjt126com
PHPyii2
                                    
    更上一层楼 
通篇阅读完整个“入门”部分，你就完成了一个完整 Yii 应用的创建。在此过程中你学到了如何实现一些常用功能，例如通过 HTML 表单从用户那获取数据，从数据库中获取数据并以分页形式显示。你还学到了如何通过 Gii 去自动生成代码。使用 Gii 生成代码把 Web 开发中多数繁杂的过程转化为仅仅填写几个表单就行。 
本章将介绍一些有助于更好使用 Yii 的资源： 

    
                                
    • 
                                
  • Apache HttpClient使用详解
                                    eksliang
httpclienthttp协议
                                    
    Http协议的重要性相信不用我多说了，HttpClient相比传统JDK自带的URLConnection，增加了易用性和灵活性（具体区别，日后我们再讨论），它不仅是客户端发送Http请求变得容易，而且也方便了开发人员测试接口（基于Http协议的），即提高了开发的效率，也方便提高代码的健壮性。因此熟练掌握HttpClient是很重要的必修内容，掌握HttpClient后，相信对于Http协议的了解会
    
                                
    • 
                                
  • zxing二维码扫描功能
                                    gundumw100
androidzxing
                                    
    经常要用到二维码扫描功能 
现给出示例代码 
 
 

import com.google.zxing.WriterException;
import com.zxing.activity.CaptureActivity;
import com.zxing.encoding.EncodingHandler;

import android.app.Activity;
import an
    
                                
    • 
                                
  • 纯HTML+CSS带说明的黄色导航菜单
                                    ini
htmlWebhtml5csshovertree
                                    
    HoverTree带说明的CSS菜单:纯HTML+CSS结构链接带说明的黄色导航 
  
在线体验效果：http://hovertree.com/texiao/css/1.htm代码如下,保存到HTML文件可以看到效果： 
  
<!DOCTYPE html >
<html >
<head>
<title>HoverTree
    
                                
    • 
                                
  • fastjson初始化对性能的影响
                                    kane_xie
fastjson序列化
                                    
    之前在项目中序列化是用thrift，性能一般，而且需要用编译器生成新的类，在序列化和反序列化的时候感觉很繁琐，因此想转到json阵营。对比了jackson，gson等框架之后，决定用fastjson，为什么呢，因为看名字感觉很快。。。 
  
网上的说法： 
   fastjson 是一个性能很好的 Java 语言实现的 JSON 解析器和生成器，来自阿里巴巴的工程师开发。 

    
                                
    • 
                                
  • 基于Mybatis封装的增删改查实现通用自动化sql
                                    mengqingyu
DAO
                                    
    1.基于map或javaBean的增删改查可实现不写dao接口和实现类以及xml，有效的提高开发速度。 
2.支持自定义注解包括主键生成、列重复验证、列名、表名等 
3.支持批量插入、批量更新、批量删除 
 
 
<bean id="dynamicSqlSessionTemplate" class="com.mqy.mybatis.support.Dynamic
    
                                
    • 
                                
  • js控制input输入框的方法封装(数字，中文，字母，浮点数等)
                                    qifeifei
javascript js
                                    
    在项目开发的时候，经常有一些输入框，控制输入的格式，而不是等输入好了再去检查格式，格式错了就报错，体验不好。   /** 数字，中文，字母,浮点数(+/-/.) 类型输入限制，只要在input标签上加上 jInput="number,chinese,alphabet,floating" 备注：floating属性只能单独用*/          
funct
    
                                
    • 
                                
  • java 计时器应用
                                    tangqi609567707
javatimer
                                    
    mport java.util.TimerTask;   import java.util.Calendar;   public class MyTask extends TimerTask {        private static final int 
    
                                
    • 
                                
  • erlang输出调用栈信息
                                    wudixiaotie
erlang
                                    
    在erlang otp的开发中，如果调用第三方的应用，会有有些错误会不打印栈信息，因为有可能第三方应用会catch然后输出自己的错误信息，所以对排查bug有很大的阻碍，这样就要求我们自己打印调用的栈信息。用这个函数：erlang:process_display (self (), backtrace).需要注意这个函数只会输出到标准错误输出。 
也可以用这个函数：erlang:get_s
    
                                
    • 
                

            

        

    




    

        

            按字母分类：
            ABCDEFGHIJKLMNOPQRSTUVWXYZ其他