ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/libev/ev.pod
(Generate patch)

Comparing libev/ev.pod (file contents):
Revision 1.210 by root, Thu Oct 30 08:09:30 2008 UTC vs.
Revision 1.217 by root, Mon Nov 17 03:37:08 2008 UTC

8 8
9=head2 EXAMPLE PROGRAM 9=head2 EXAMPLE PROGRAM
10 10
11 // a single header file is required 11 // a single header file is required
12 #include <ev.h> 12 #include <ev.h>
13
14 #include <stdio.h> // for puts
13 15
14 // every watcher type has its own typedef'd struct 16 // every watcher type has its own typedef'd struct
15 // with the name ev_TYPE 17 // with the name ev_TYPE
16 ev_io stdin_watcher; 18 ev_io stdin_watcher;
17 ev_timer timeout_watcher; 19 ev_timer timeout_watcher;
417i.e. keep at least one watcher active per fd at all times. Stopping and 419i.e. keep at least one watcher active per fd at all times. Stopping and
418starting a watcher (without re-setting it) also usually doesn't cause 420starting a watcher (without re-setting it) also usually doesn't cause
419extra overhead. A fork can both result in spurious notifications as well 421extra overhead. A fork can both result in spurious notifications as well
420as in libev having to destroy and recreate the epoll object, which can 422as in libev having to destroy and recreate the epoll object, which can
421take considerable time and thus should be avoided. 423take considerable time and thus should be avoided.
424
425All this means that, in practice, C<EVBACKEND_SELECT> can be as fast or
426faster than epoll for maybe up to a hundred file descriptors, depending on
427the usage. So sad.
422 428
423While nominally embeddable in other event loops, this feature is broken in 429While nominally embeddable in other event loops, this feature is broken in
424all kernel versions tested so far. 430all kernel versions tested so far.
425 431
426This backend maps C<EV_READ> and C<EV_WRITE> in the same way as 432This backend maps C<EV_READ> and C<EV_WRITE> in the same way as
1415 else 1421 else
1416 { 1422 {
1417 // callback was invoked, but there was some activity, re-arm 1423 // callback was invoked, but there was some activity, re-arm
1418 // the watcher to fire in last_activity + 60, which is 1424 // the watcher to fire in last_activity + 60, which is
1419 // guaranteed to be in the future, so "again" is positive: 1425 // guaranteed to be in the future, so "again" is positive:
1420 w->again = timeout - now; 1426 w->repeat = timeout - now;
1421 ev_timer_again (EV_A_ w); 1427 ev_timer_again (EV_A_ w);
1422 } 1428 }
1423 } 1429 }
1424 1430
1425To summarise the callback: first calculate the real timeout (defined 1431To summarise the callback: first calculate the real timeout (defined
1932C<stat> on that path in regular intervals (or when the OS says it changed) 1938C<stat> on that path in regular intervals (or when the OS says it changed)
1933and sees if it changed compared to the last time, invoking the callback if 1939and sees if it changed compared to the last time, invoking the callback if
1934it did. 1940it did.
1935 1941
1936The path does not need to exist: changing from "path exists" to "path does 1942The path does not need to exist: changing from "path exists" to "path does
1937not exist" is a status change like any other. The condition "path does 1943not exist" is a status change like any other. The condition "path does not
1938not exist" is signified by the C<st_nlink> field being zero (which is 1944exist" (or more correctly "path cannot be stat'ed") is signified by the
1939otherwise always forced to be at least one) and all the other fields of 1945C<st_nlink> field being zero (which is otherwise always forced to be at
1940the stat buffer having unspecified contents. 1946least one) and all the other fields of the stat buffer having unspecified
1947contents.
1941 1948
1942The path I<must not> end in a slash or contain special components such as 1949The path I<must not> end in a slash or contain special components such as
1943C<.> or C<..>. The path I<should> be absolute: If it is relative and 1950C<.> or C<..>. The path I<should> be absolute: If it is relative and
1944your working directory changes, then the behaviour is undefined. 1951your working directory changes, then the behaviour is undefined.
1945 1952
1955This watcher type is not meant for massive numbers of stat watchers, 1962This watcher type is not meant for massive numbers of stat watchers,
1956as even with OS-supported change notifications, this can be 1963as even with OS-supported change notifications, this can be
1957resource-intensive. 1964resource-intensive.
1958 1965
1959At the time of this writing, the only OS-specific interface implemented 1966At the time of this writing, the only OS-specific interface implemented
1960is the Linux inotify interface (implementing kqueue support is left as 1967is the Linux inotify interface (implementing kqueue support is left as an
1961an exercise for the reader. Note, however, that the author sees no way 1968exercise for the reader. Note, however, that the author sees no way of
1962of implementing C<ev_stat> semantics with kqueue). 1969implementing C<ev_stat> semantics with kqueue, except as a hint).
1963 1970
1964=head3 ABI Issues (Largefile Support) 1971=head3 ABI Issues (Largefile Support)
1965 1972
1966Libev by default (unless the user overrides this) uses the default 1973Libev by default (unless the user overrides this) uses the default
1967compilation environment, which means that on systems with large file 1974compilation environment, which means that on systems with large file
1978to exchange stat structures with application programs compiled using the 1985to exchange stat structures with application programs compiled using the
1979default compilation environment. 1986default compilation environment.
1980 1987
1981=head3 Inotify and Kqueue 1988=head3 Inotify and Kqueue
1982 1989
1983When C<inotify (7)> support has been compiled into libev (generally 1990When C<inotify (7)> support has been compiled into libev and present at
1984only available with Linux 2.6.25 or above due to bugs in earlier 1991runtime, it will be used to speed up change detection where possible. The
1985implementations) and present at runtime, it will be used to speed up 1992inotify descriptor will be created lazily when the first C<ev_stat>
1986change detection where possible. The inotify descriptor will be created 1993watcher is being started.
1987lazily when the first C<ev_stat> watcher is being started.
1988 1994
1989Inotify presence does not change the semantics of C<ev_stat> watchers 1995Inotify presence does not change the semantics of C<ev_stat> watchers
1990except that changes might be detected earlier, and in some cases, to avoid 1996except that changes might be detected earlier, and in some cases, to avoid
1991making regular C<stat> calls. Even in the presence of inotify support 1997making regular C<stat> calls. Even in the presence of inotify support
1992there are many cases where libev has to resort to regular C<stat> polling, 1998there are many cases where libev has to resort to regular C<stat> polling,
1993but as long as the path exists, libev usually gets away without polling. 1999but as long as kernel 2.6.25 or newer is used (2.6.24 and older have too
2000many bugs), the path exists (i.e. stat succeeds), and the path resides on
2001a local filesystem (libev currently assumes only ext2/3, jfs, reiserfs and
2002xfs are fully working) libev usually gets away without polling.
1994 2003
1995There is no support for kqueue, as apparently it cannot be used to 2004There is no support for kqueue, as apparently it cannot be used to
1996implement this functionality, due to the requirement of having a file 2005implement this functionality, due to the requirement of having a file
1997descriptor open on the object at all times, and detecting renames, unlinks 2006descriptor open on the object at all times, and detecting renames, unlinks
1998etc. is difficult. 2007etc. is difficult.
2008
2009=head3 C<stat ()> is a synchronous operation
2010
2011Libev doesn't normally do any kind of I/O itself, and so is not blocking
2012the process. The exception are C<ev_stat> watchers - those call C<stat
2013()>, which is a synchronous operation.
2014
2015For local paths, this usually doesn't matter: unless the system is very
2016busy or the intervals between stat's are large, a stat call will be fast,
2017as the path data is suually in memory already (except when starting the
2018watcher).
2019
2020For networked file systems, calling C<stat ()> can block an indefinite
2021time due to network issues, and even under good conditions, a stat call
2022often takes multiple milliseconds.
2023
2024Therefore, it is best to avoid using C<ev_stat> watchers on networked
2025paths, although this is fully supported by libev.
1999 2026
2000=head3 The special problem of stat time resolution 2027=head3 The special problem of stat time resolution
2001 2028
2002The C<stat ()> system call only supports full-second resolution portably, 2029The C<stat ()> system call only supports full-second resolution portably,
2003and even on systems where the resolution is higher, most file systems 2030and even on systems where the resolution is higher, most file systems

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines