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

Comparing libev/ev.pod (file contents):
Revision 1.124 by root, Fri Feb 1 13:41:03 2008 UTC vs.
Revision 1.131 by root, Tue Feb 19 17:09:28 2008 UTC

… …
505=item ev_loop_fork (loop) 505=item ev_loop_fork (loop)
506 506
507Like C<ev_default_fork>, but acts on an event loop created by 507Like C<ev_default_fork>, but acts on an event loop created by
508C<ev_loop_new>. Yes, you have to call this on every allocated event loop 508C<ev_loop_new>. Yes, you have to call this on every allocated event loop
509after fork, and how you do this is entirely your own problem. 509after fork, and how you do this is entirely your own problem.
510
511=item int ev_is_default_loop (loop)
512
513Returns true when the given loop actually is the default loop, false otherwise.
510 514
511=item unsigned int ev_loop_count (loop) 515=item unsigned int ev_loop_count (loop)
512 516
513Returns the count of loop iterations for the loop, which is identical to 517Returns the count of loop iterations for the loop, which is identical to
514the number of times libev did poll for new events. It starts at C<0> and 518the number of times libev did poll for new events. It starts at C<0> and
… …
2078is that the author does not know of a simple (or any) algorithm for a 2082is that the author does not know of a simple (or any) algorithm for a
2079multiple-writer-single-reader queue that works in all cases and doesn't 2083multiple-writer-single-reader queue that works in all cases and doesn't
2080need elaborate support such as pthreads. 2084need elaborate support such as pthreads.
2081 2085
2082That means that if you want to queue data, you have to provide your own 2086That means that if you want to queue data, you have to provide your own
2083queue. And here is how you would implement locking: 2087queue. But at least I can tell you would implement locking around your
2088queue:
2084 2089
2085=over 4 2090=over 4
2086 2091
2087=item queueing from a signal handler context 2092=item queueing from a signal handler context
2088 2093
… …
2097 { 2102 {
2098 sometype data; 2103 sometype data;
2099 2104
2100 // no locking etc. 2105 // no locking etc.
2101 queue_put (data); 2106 queue_put (data);
2102 ev_async_send (DEFAULT_LOOP, &mysig); 2107 ev_async_send (DEFAULT_ &mysig);
2103 } 2108 }
2104 2109
2105 static void 2110 static void
2106 mysig_cb (EV_P_ ev_async *w, int revents) 2111 mysig_cb (EV_P_ ev_async *w, int revents)
2107 { 2112 {
… …
2125 2130
2126=item queueing from a thread context 2131=item queueing from a thread context
2127 2132
2128The strategy for threads is different, as you cannot (easily) block 2133The strategy for threads is different, as you cannot (easily) block
2129threads but you can easily preempt them, so to queue safely you need to 2134threads but you can easily preempt them, so to queue safely you need to
2130emply a traditional mutex lock, such as in this pthread example: 2135employ a traditional mutex lock, such as in this pthread example:
2131 2136
2132 static ev_async mysig; 2137 static ev_async mysig;
2133 static pthread_mutex_t mymutex = PTHREAD_MUTEX_INITIALIZER; 2138 static pthread_mutex_t mymutex = PTHREAD_MUTEX_INITIALIZER;
2134 2139
2135 static void 2140 static void
… …
2138 // only need to lock the actual queueing operation 2143 // only need to lock the actual queueing operation
2139 pthread_mutex_lock (&mymutex); 2144 pthread_mutex_lock (&mymutex);
2140 queue_put (data); 2145 queue_put (data);
2141 pthread_mutex_unlock (&mymutex); 2146 pthread_mutex_unlock (&mymutex);
2142 2147
2143 ev_async_send (DEFAULT_LOOP, &mysig); 2148 ev_async_send (DEFAULT_ &mysig);
2144 } 2149 }
2145 2150
2146 static void 2151 static void
2147 mysig_cb (EV_P_ ev_async *w, int revents) 2152 mysig_cb (EV_P_ ev_async *w, int revents)
2148 { 2153 {
… …
2695be detected at runtime. 2700be detected at runtime.
2696 2701
2697=item EV_ATOMIC_T 2702=item EV_ATOMIC_T
2698 2703
2699Libev requires an integer type (suitable for storing C<0> or C<1>) whose 2704Libev requires an integer type (suitable for storing C<0> or C<1>) whose
2700access is atomic with respect to other threads or signal contexts. No such type 2705access is atomic with respect to other threads or signal contexts. No such
2701is easily found using, so you cna provide your own type that you know is safe. 2706type is easily found in the C language, so you can provide your own type
2707that you know is safe for your purposes. It is used both for signal handler "locking"
2708as well as for signal and thread safety in C<ev_async> watchers.
2702 2709
2703In the absense of this define, libev will use C<sig_atomic_t volatile> 2710In the absense of this define, libev will use C<sig_atomic_t volatile>
2704from F<signal.h>, which is usually good enough on most platforms. 2711(from F<signal.h>), which is usually good enough on most platforms.
2705 2712
2706=item EV_H 2713=item EV_H
2707 2714
2708The name of the F<ev.h> header file used to include it. The default if 2715The name of the F<ev.h> header file used to include it. The default if
2709undefined is C<"ev.h"> in F<event.h>, F<ev.c> and F<ev++.h>. This can be 2716undefined is C<"ev.h"> in F<event.h>, F<ev.c> and F<ev++.h>. This can be
… …
2910=item Changing timer/periodic watchers (by autorepeat or calling again): O(log skipped_other_timers) 2917=item Changing timer/periodic watchers (by autorepeat or calling again): O(log skipped_other_timers)
2911 2918
2912That means that changing a timer costs less than removing/adding them 2919That means that changing a timer costs less than removing/adding them
2913as only the relative motion in the event queue has to be paid for. 2920as only the relative motion in the event queue has to be paid for.
2914 2921
2915=item Starting io/check/prepare/idle/signal/child watchers: O(1) 2922=item Starting io/check/prepare/idle/signal/child/fork/async watchers: O(1)
2916 2923
2917These just add the watcher into an array or at the head of a list. 2924These just add the watcher into an array or at the head of a list.
2918 2925
2919=item Stopping check/prepare/idle watchers: O(1) 2926=item Stopping check/prepare/idle/fork/async watchers: O(1)
2920 2927
2921=item Stopping an io/signal/child watcher: O(number_of_watchers_for_this_(fd/signal/pid % EV_PID_HASHSIZE)) 2928=item Stopping an io/signal/child watcher: O(number_of_watchers_for_this_(fd/signal/pid % EV_PID_HASHSIZE))
2922 2929
2923These watchers are stored in lists then need to be walked to find the 2930These watchers are stored in lists then need to be walked to find the
2924correct watcher to remove. The lists are usually short (you don't usually 2931correct watcher to remove. The lists are usually short (you don't usually
… …
2940=item Priority handling: O(number_of_priorities) 2947=item Priority handling: O(number_of_priorities)
2941 2948
2942Priorities are implemented by allocating some space for each 2949Priorities are implemented by allocating some space for each
2943priority. When doing priority-based operations, libev usually has to 2950priority. When doing priority-based operations, libev usually has to
2944linearly search all the priorities, but starting/stopping and activating 2951linearly search all the priorities, but starting/stopping and activating
2945watchers becomes O(1) w.r.t. prioritiy handling. 2952watchers becomes O(1) w.r.t. priority handling.
2953
2954=item Sending an ev_async: O(1)
2955
2956=item Processing ev_async_send: O(number_of_async_watchers)
2957
2958=item Processing signals: O(max_signal_number)
2959
2960Sending involves a syscall I<iff> there were no other C<ev_async_send>
2961calls in the current loop iteration. Checking for async and signal events
2962involves iterating over all running async watchers or all signal numbers.
2946 2963
2947=back 2964=back
2948 2965
2949 2966
2950=head1 Win32 platform limitations and workarounds 2967=head1 Win32 platform limitations and workarounds

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines