ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/EV/EV.pm
(Generate patch)

Comparing EV/EV.pm (file contents):
Revision 1.6 by root, Sat Oct 27 07:30:10 2007 UTC vs.
Revision 1.47 by root, Fri Nov 23 13:08:55 2007 UTC

1=head1 NAME 1=head1 NAME
2 2
3EV - perl interface to libevent, monkey.org/~provos/libevent/ 3EV - perl interface to libev, a high performance full-featured event loop
4 4
5=head1 SYNOPSIS 5=head1 SYNOPSIS
6 6
7 use EV; 7 use EV;
8 8
9 # TIMER 9 # TIMERS
10 10
11 my $w = EV::timer 2, 0, sub { 11 my $w = EV::timer 2, 0, sub {
12 warn "is called after 2s"; 12 warn "is called after 2s";
13 }; 13 };
14 14
15 my $w = EV::timer 2, 1, sub { 15 my $w = EV::timer 2, 2, sub {
16 warn "is called roughly every 2s (repeat = 1)"; 16 warn "is called roughly every 2s (repeat = 2)";
17 }; 17 };
18 18
19 undef $w; # destroy event watcher again 19 undef $w; # destroy event watcher again
20 20
21 # IO
22
23 my $w = EV::timer_abs 0, 60, sub { 21 my $w = EV::periodic 0, 60, 0, sub {
24 warn "is called every minute, on the minute, exactly"; 22 warn "is called every minute, on the minute, exactly";
25 }; 23 };
26 24
25 # IO
26
27 my $w = EV::io \*STDIN, EV::READ | EV::PERSIST, sub { 27 my $w = EV::io *STDIN, EV::READ, sub {
28 my ($w, $events) = @_; # all callbacks get the watcher object and event mask 28 my ($w, $revents) = @_; # all callbacks receive the watcher and event mask
29 if ($events & EV::TIMEOUT) {
30 warn "nothign received on stdin for 10 seconds, retrying";
31 } else {
32 warn "stdin is readable, you entered: ", <STDIN>; 29 warn "stdin is readable, you entered: ", <STDIN>;
33 }
34 }; 30 };
35 $w->timeout (10); 31
32 # SIGNALS
33
34 my $w = EV::signal 'QUIT', sub {
35 warn "sigquit received\n";
36 };
37
38 # CHILD/PID STATUS CHANGES
36 39
40 my $w = EV::child 666, sub {
41 my ($w, $revents) = @_;
42 my $status = $w->rstatus;
43 };
44
37 # MAINLOOP 45 # MAINLOOP
38 EV::dispatch; # loop as long as watchers are active 46 EV::loop; # loop until EV::unloop is called or all watchers stop
39 EV::loop; # the same thing 47 EV::loop EV::LOOP_ONESHOT; # block until at least one event could be handled
40 EV::loop EV::LOOP_ONCE; 48 EV::loop EV::LOOP_NONBLOCK; # try to handle same events, but do not block
41 EV::loop EV::LOOP_ONSHOT;
42 49
43=head1 DESCRIPTION 50=head1 DESCRIPTION
44 51
45This module provides an interface to libevent 52This module provides an interface to libev
46(L<http://monkey.org/~provos/libevent/>). You probably should acquaint 53(L<http://software.schmorp.de/pkg/libev.html>).
47yourself with its documentation and source code to be able to use this
48module fully.
49
50Please note thta this module disables the libevent EPOLL method by
51default, see BUGS, below, if you need to enable it.
52 54
53=cut 55=cut
54 56
55package EV; 57package EV;
56 58
57use strict; 59use strict;
58 60
59BEGIN { 61BEGIN {
60 our $VERSION = '0.01'; 62 our $VERSION = '1.2';
61 use XSLoader; 63 use XSLoader;
62 XSLoader::load "EV", $VERSION; 64 XSLoader::load "EV", $VERSION;
63} 65}
64 66
65=head1 FUNCTIONAL INTERFACE 67@EV::Io::ISA =
68@EV::Timer::ISA =
69@EV::Periodic::ISA =
70@EV::Signal::ISA =
71@EV::Idle::ISA =
72@EV::Prepare::ISA =
73@EV::Check::ISA =
74@EV::Child::ISA = "EV::Watcher";
75
76=head1 BASIC INTERFACE
66 77
67=over 4 78=over 4
68 79
69=item $EV::NPRI 80=item $EV::DIED
70 81
71How many priority levels are available. 82Must contain a reference to a function that is called when a callback
83throws an exception (with $@ containing thr error). The default prints an
84informative message and continues.
85
86If this callback throws an exception it will be silently ignored.
87
88=item $time = EV::time
89
90Returns the current time in (fractional) seconds since the epoch.
72 91
73=item $time = EV::now 92=item $time = EV::now
74 93
75Returns the time in (fractional) seconds since the epoch. 94Returns the time the last event loop iteration has been started. This
76 95is the time that (relative) timers are based on, and refering to it is
77=item $version = EV::version 96usually faster then calling EV::time.
78 97
79=item $method = EV::method 98=item $method = EV::method
80 99
81Return version string and event polling method used. 100Returns an integer describing the backend used by libev (EV::METHOD_SELECT
101or EV::METHOD_EPOLL).
82 102
83=item EV::loop $flags # EV::LOOP_ONCE, EV::LOOP_ONESHOT 103=item EV::loop [$flags]
84 104
85=item EV::loopexit $after 105Begin checking for events and calling callbacks. It returns when a
106callback calls EV::unloop.
86 107
87Exit any active loop or dispatch after C<$after> seconds or immediately if 108The $flags argument can be one of the following:
88C<$after> is missing or zero.
89 109
90=item EV::dispatch 110 0 as above
111 EV::LOOP_ONESHOT block at most once (wait, but do not loop)
112 EV::LOOP_NONBLOCK do not block at all (fetch/handle events but do not wait)
91 113
92Same as C<EV::loop 0>. 114=item EV::unloop [$how]
93 115
94=item EV::event $callback 116When called with no arguments or an argument of EV::UNLOOP_ONE, makes the
117innermost call to EV::loop return.
95 118
96Creates a new event watcher waiting for nothing, calling the given callback. 119When called with an argument of EV::UNLOOP_ALL, all calls to EV::loop will return as
120fast as possible.
97 121
122=item EV::once $fh_or_undef, $events, $timeout, $cb->($events)
123
124This function rolls together an I/O and a timer watcher for a single
125one-shot event without the need for managing a watcher object.
126
127If C<$fh_or_undef> is a filehandle or file descriptor, then C<$events>
128must be a bitset containing either C<EV::READ>, C<EV::WRITE> or C<EV::READ
129| EV::WRITE>, indicating the type of I/O event you want to wait for. If
130you do not want to wait for some I/O event, specify C<undef> for
131C<$fh_or_undef> and C<0> for C<$events>).
132
133If timeout is C<undef> or negative, then there will be no
134timeout. Otherwise a EV::timer with this value will be started.
135
136When an error occurs or either the timeout or I/O watcher triggers, then
137the callback will be called with the received event set (in general
138you can expect it to be a combination of C<EV:ERROR>, C<EV::READ>,
139C<EV::WRITE> and C<EV::TIMEOUT>).
140
141EV::once doesn't return anything: the watchers stay active till either
142of them triggers, then they will be stopped and freed, and the callback
143invoked.
144
145=back
146
147=head2 WATCHER
148
149A watcher is an object that gets created to record your interest in some
150event. For instance, if you want to wait for STDIN to become readable, you
151would create an EV::io watcher for that:
152
153 my $watcher = EV::io *STDIN, EV::READ, sub {
154 my ($watcher, $revents) = @_;
155 warn "yeah, STDIN should not be readable without blocking!\n"
156 };
157
158All watchers can be active (waiting for events) or inactive (paused). Only
159active watchers will have their callbacks invoked. All callbacks will be
160called with at least two arguments: the watcher and a bitmask of received
161events.
162
163Each watcher type has its associated bit in revents, so you can use the
164same callback for multiple watchers. The event mask is named after the
165type, i..e. EV::child sets EV::CHILD, EV::prepare sets EV::PREPARE,
166EV::periodic sets EV::PERIODIC and so on, with the exception of IO events
167(which can set both EV::READ and EV::WRITE bits), and EV::timer (which
168uses EV::TIMEOUT).
169
170In the rare case where one wants to create a watcher but not start it at
171the same time, each constructor has a variant with a trailing C<_ns> in
172its name, e.g. EV::io has a non-starting variant EV::io_ns and so on.
173
174Please note that a watcher will automatically be stopped when the watcher
175object is destroyed, so you I<need> to keep the watcher objects returned by
176the constructors.
177
178Also, all methods changing some aspect of a watcher (->set, ->priority,
179->fh and so on) automatically stop and start it again if it is active,
180which means pending events get lost.
181
182=head2 WATCHER TYPES
183
184Now lets move to the existing watcher types and asociated methods.
185
186The following methods are available for all watchers. Then followes a
187description of each watcher constructor (EV::io, EV::timer, EV::periodic,
188EV::signal, EV::child, EV::idle, EV::prepare and EV::check), followed by
189any type-specific methods (if any).
190
191=over 4
192
193=item $w->start
194
195Starts a watcher if it isn't active already. Does nothing to an already
196active watcher. By default, all watchers start out in the active state
197(see the description of the C<_ns> variants if you need stopped watchers).
198
199=item $w->stop
200
201Stop a watcher if it is active. Also clear any pending events (events that
202have been received but that didn't yet result in a callback invocation),
203regardless of wether the watcher was active or not.
204
205=item $bool = $w->is_active
206
207Returns true if the watcher is active, false otherwise.
208
209=item $current_data = $w->data
210
211=item $old_data = $w->data ($new_data)
212
213Queries a freely usable data scalar on the watcher and optionally changes
214it. This is a way to associate custom data with a watcher:
215
216 my $w = EV::timer 60, 0, sub {
217 warn $_[0]->data;
218 };
219 $w->data ("print me!");
220
221=item $current_cb = $w->cb
222
223=item $old_cb = $w->cb ($new_cb)
224
225Queries the callback on the watcher and optionally changes it. You can do
226this at any time without the watcher restarting.
227
228=item $current_priority = $w->priority
229
230=item $old_priority = $w->priority ($new_priority)
231
232Queries the priority on the watcher and optionally changes it. Pending
233watchers with higher priority will be invoked first. The valid range of
234priorities lies between EV::MAXPRI (default 2) and EV::MINPRI (default
235-2). If the priority is outside this range it will automatically be
236normalised to the nearest valid priority.
237
238The default priority of any newly-created weatcher is 0.
239
240=item $w->trigger ($revents)
241
242Call the callback *now* with the given event mask.
243
244
98=item my $w = EV::io $fileno_or_fh, $eventmask, $callback 245=item $w = EV::io $fileno_or_fh, $eventmask, $callback
99 246
100=item my $w = EV::io_ns $fileno_or_fh, $eventmask, $callback 247=item $w = EV::io_ns $fileno_or_fh, $eventmask, $callback
101 248
102As long as the returned watcher object is alive, call the C<$callback> 249As long as the returned watcher object is alive, call the C<$callback>
103when the events specified in C<$eventmask> happen. Initially, the timeout 250when the events specified in C<$eventmask>.
104is disabled.
105 251
106The C<io_ns> variant doesn't add/start the newly created watcher.
107
108Eventmask can be one or more of these constants ORed together: 252The $eventmask can be one or more of these constants ORed together:
109 253
110 EV::READ wait until read() wouldn't block anymore 254 EV::READ wait until read() wouldn't block anymore
111 EV::WRITE wait until write() wouldn't block anymore 255 EV::WRITE wait until write() wouldn't block anymore
112 EV::PERSIST stay active after an event occured
113 256
257The C<io_ns> variant doesn't start (activate) the newly created watcher.
258
259=item $w->set ($fileno_or_fh, $eventmask)
260
261Reconfigures the watcher, see the constructor above for details. Can be
262called at any time.
263
264=item $current_fh = $w->fh
265
266=item $old_fh = $w->fh ($new_fh)
267
268Returns the previously set filehandle and optionally set a new one.
269
270=item $current_eventmask = $w->events
271
272=item $old_eventmask = $w->events ($new_eventmask)
273
274Returns the previously set event mask and optionally set a new one.
275
276
114=item my $w = EV::timer $after, $repeat, $callback 277=item $w = EV::timer $after, $repeat, $callback
115 278
116=item my $w = EV::timer_ns $after, $repeat, $callback 279=item $w = EV::timer_ns $after, $repeat, $callback
117 280
118Calls the callback after C<$after> seconds. If C<$repeat> is true, the 281Calls the callback after C<$after> seconds. If C<$repeat> is non-zero,
119timer will be restarted after the callback returns. This means that the 282the timer will be restarted (with the $repeat value as $after) after the
120callback would be called roughly every C<$after> seconds, prolonged by the 283callback returns.
121time the callback takes.
122 284
285This means that the callback would be called roughly after C<$after>
286seconds, and then every C<$repeat> seconds. The timer does his best not
287to drift, but it will not invoke the timer more often then once per event
288loop iteration, and might drift in other cases. If that isn't acceptable,
289look at EV::periodic, which can provide long-term stable timers.
290
291The timer is based on a monotonic clock, that is, if somebody is sitting
292in front of the machine while the timer is running and changes the system
293clock, the timer will nevertheless run (roughly) the same time.
294
123The C<timer_ns> variant doesn't add/start the newly created watcher. 295The C<timer_ns> variant doesn't start (activate) the newly created watcher.
124 296
125=item my $w = EV::timer_abs $at, $interval, $callback 297=item $w->set ($after, $repeat)
126 298
127=item my $w = EV::timer_abs_ns $at, $interval, $callback 299Reconfigures the watcher, see the constructor above for details. Can be at
300any time.
128 301
129Similar to EV::timer, but the time is given as an absolute point in time 302=item $w->again
130(C<$at>), plus an optional C<$interval>.
131 303
132If the C<$interval> is zero, then the callback will be called at the time 304Similar to the C<start> method, but has special semantics for repeating timers:
133C<$at> if that is in the future, or as soon as possible if its in the
134past. It will not automatically repeat.
135 305
136If the C<$interval> is nonzero, then the watcher will always be scheduled 306If the timer is active and non-repeating, it will be stopped.
137to time out at the next C<$at + integer * $interval> time.
138 307
139This can be used to schedule a callback to run at very regular intervals, 308If the timer is active and repeating, reset the timeout to occur
140as long as the processing time is less then the interval (otherwise 309C<$repeat> seconds after now.
141obviously events will be skipped).
142 310
143The C<timer_abs_ns> variant doesn't add/start the newly created watcher. 311If the timer is inactive and repeating, start it using the repeat value.
144 312
145=item my $w = EV::signal $signum, $callback 313Otherwise do nothing.
146 314
147=item my $w = EV::signal_ns $signum, $callback 315This behaviour is useful when you have a timeout for some IO
316operation. You create a timer object with the same value for C<$after> and
317C<$repeat>, and then, in the read/write watcher, run the C<again> method
318on the timeout.
148 319
149Call the callback when signal $signum is received.
150 320
151The C<signal_ns> variant doesn't add/start the newly created watcher. 321=item $w = EV::periodic $at, $interval, $reschedule_cb, $callback
322
323=item $w = EV::periodic_ns $at, $interval, $reschedule_cb, $callback
324
325Similar to EV::timer, but is not based on relative timeouts but on
326absolute times. Apart from creating "simple" timers that trigger "at" the
327specified time, it can also be used for non-drifting absolute timers and
328more complex, cron-like, setups that are not adversely affected by time
329jumps (i.e. when the system clock is changed by explicit date -s or other
330means such as ntpd). It is also the most complex watcher type in EV.
331
332It has three distinct "modes":
333
334=over 4
335
336=item * absolute timer ($interval = $reschedule_cb = 0)
337
338This time simply fires at the wallclock time C<$at> and doesn't repeat. It
339will not adjust when a time jump occurs, that is, if it is to be run
340at January 1st 2011 then it will run when the system time reaches or
341surpasses this time.
342
343=item * non-repeating interval timer ($interval > 0, $reschedule_cb = 0)
344
345In this mode the watcher will always be scheduled to time out at the
346next C<$at + N * $interval> time (for some integer N) and then repeat,
347regardless of any time jumps.
348
349This can be used to create timers that do not drift with respect to system
350time:
351
352 my $hourly = EV::periodic 0, 3600, 0, sub { print "once/hour\n" };
353
354That doesn't mean there will always be 3600 seconds in between triggers,
355but only that the the clalback will be called when the system time shows a
356full hour (UTC).
357
358Another way to think about it (for the mathematically inclined) is that
359EV::periodic will try to run the callback in this mode at the next
360possible time where C<$time = $at (mod $interval)>, regardless of any time
361jumps.
362
363=item * manual reschedule mode ($reschedule_cb = coderef)
364
365In this mode $interval and $at are both being ignored. Instead, each
366time the periodic watcher gets scheduled, the reschedule callback
367($reschedule_cb) will be called with the watcher as first, and the current
368time as second argument.
369
370I<This callback MUST NOT stop or destroy this or any other periodic
371watcher, ever>. If you need to stop it, return 1e30 and stop it
372afterwards.
373
374It must return the next time to trigger, based on the passed time value
375(that is, the lowest time value larger than to the second argument). It
376will usually be called just before the callback will be triggered, but
377might be called at other times, too.
378
379This can be used to create very complex timers, such as a timer that
380triggers on each midnight, local time (actually 24 hours after the last
381midnight, to keep the example simple. If you know a way to do it correctly
382in about the same space (without requiring elaborate modules), drop me a
383note :):
384
385 my $daily = EV::periodic 0, 0, sub {
386 my ($w, $now) = @_;
387
388 use Time::Local ();
389 my (undef, undef, undef, $d, $m, $y) = localtime $now;
390 86400 + Time::Local::timelocal 0, 0, 0, $d, $m, $y
391 }, sub {
392 print "it's midnight or likely shortly after, now\n";
393 };
152 394
153=back 395=back
154 396
155=head1 THE EV::Event CLASS 397The C<periodic_ns> variant doesn't start (activate) the newly created watcher.
156 398
157All EV functions creating an event watcher (designated by C<my $w => 399=item $w->set ($at, $interval, $reschedule_cb)
158above) support the following methods on the returned watcher object:
159 400
160=over 4 401Reconfigures the watcher, see the constructor above for details. Can be at
402any time.
161 403
162=item $w->add ($timeout) 404=item $w->again
163 405
164Stops and (re-)starts the event watcher, setting the optional timeout to 406Simply stops and starts the watcher again.
165the given value, or clearing the timeout if none is given.
166 407
167=item $w->start
168 408
169Stops and (re-)starts the event watcher without touching the timeout. 409=item $w = EV::signal $signal, $callback
170 410
171=item $w->del 411=item $w = EV::signal_ns $signal, $callback
172 412
413Call the callback when $signal is received (the signal can be specified
414by number or by name, just as with kill or %SIG).
415
416EV will grab the signal for the process (the kernel only allows one
417component to receive a signal at a time) when you start a signal watcher,
418and removes it again when you stop it. Perl does the same when you
419add/remove callbacks to %SIG, so watch out.
420
421You can have as many signal watchers per signal as you want.
422
423The C<signal_ns> variant doesn't start (activate) the newly created watcher.
424
425=item $w->set ($signal)
426
427Reconfigures the watcher, see the constructor above for details. Can be at
428any time.
429
430=item $current_signum = $w->signal
431
432=item $old_signum = $w->signal ($new_signal)
433
434Returns the previously set signal (always as a number not name) and
435optionally set a new one.
436
437
438=item $w = EV::child $pid, $callback
439
440=item $w = EV::child_ns $pid, $callback
441
442Call the callback when a status change for pid C<$pid> (or any pid
443if C<$pid> is 0) has been received. More precisely: when the process
444receives a SIGCHLD, EV will fetch the outstanding exit/wait status for all
445changed/zombie children and call the callback.
446
447You can access both status and pid by using the C<rstatus> and C<rpid>
448methods on the watcher object.
449
450You can have as many pid watchers per pid as you want.
451
452The C<child_ns> variant doesn't start (activate) the newly created watcher.
453
173=item $w->stop 454=item $w->set ($pid)
174 455
175Stop the event watcher if it was started. 456Reconfigures the watcher, see the constructor above for details. Can be at
457any time.
176 458
177=item $current_callback = $w->cb
178
179=item $old_callback = $w->cb ($new_callback)
180
181Return the previously set callback and optionally set a new one.
182
183=item $current_fh = $w->fh 459=item $current_pid = $w->pid
184 460
185=item $old_fh = $w->fh ($new_fh) 461=item $old_pid = $w->pid ($new_pid)
186 462
187Returns the previously set filehandle and optionally set a new one.
188
189=item $current_eventmask = $w->events
190
191=item $old_eventmask = $w->events ($new_eventmask)
192
193Returns the previously set event mask and optionally set a new one. 463Returns the previously set process id and optionally set a new one.
194 464
195=item $w->timeout ($after, $repeat) 465=item $exit_status = $w->rstatus
196 466
197Resets the timeout (see C<EV::timer> for details). 467Return the exit/wait status (as returned by waitpid, see the waitpid entry
468in perlfunc).
198 469
199=item $w->timeout_abs ($at, $interval) 470=item $pid = $w->rpid
200 471
201Resets the timeout (see C<EV::timer_abs> for details). 472Return the pid of the awaited child (useful when you have installed a
473watcher for all pids).
202 474
203=item $w->priority_set ($priority)
204 475
205Set the priority of the watcher to C<$priority> (0 <= $priority < $EV::NPRI). 476=item $w = EV::idle $callback
477
478=item $w = EV::idle_ns $callback
479
480Call the callback when there are no pending io, timer/periodic, signal or
481child events, i.e. when the process is idle.
482
483The process will not block as long as any idle watchers are active, and
484they will be called repeatedly until stopped.
485
486The C<idle_ns> variant doesn't start (activate) the newly created watcher.
487
488
489=item $w = EV::prepare $callback
490
491=item $w = EV::prepare_ns $callback
492
493Call the callback just before the process would block. You can still
494create/modify any watchers at this point.
495
496See the EV::check watcher, below, for explanations and an example.
497
498The C<prepare_ns> variant doesn't start (activate) the newly created watcher.
499
500
501=item $w = EV::check $callback
502
503=item $w = EV::check_ns $callback
504
505Call the callback just after the process wakes up again (after it has
506gathered events), but before any other callbacks have been invoked.
507
508This is used to integrate other event-based software into the EV
509mainloop: You register a prepare callback and in there, you create io and
510timer watchers as required by the other software. Here is a real-world
511example of integrating Net::SNMP (with some details left out):
512
513 our @snmp_watcher;
514
515 our $snmp_prepare = EV::prepare sub {
516 # do nothing unless active
517 $dispatcher->{_event_queue_h}
518 or return;
519
520 # make the dispatcher handle any outstanding stuff
521 ... not shown
522
523 # create an IO watcher for each and every socket
524 @snmp_watcher = (
525 (map { EV::io $_, EV::READ, sub { } }
526 keys %{ $dispatcher->{_descriptors} }),
527
528 EV::timer +($event->[Net::SNMP::Dispatcher::_ACTIVE]
529 ? $event->[Net::SNMP::Dispatcher::_TIME] - EV::now : 0),
530 0, sub { },
531 );
532 };
533
534The callbacks are irrelevant (and are not even being called), the
535only purpose of those watchers is to wake up the process as soon as
536one of those events occurs (socket readable, or timer timed out). The
537corresponding EV::check watcher will then clean up:
538
539 our $snmp_check = EV::check sub {
540 # destroy all watchers
541 @snmp_watcher = ();
542
543 # make the dispatcher handle any new stuff
544 ... not shown
545 };
546
547The callbacks of the created watchers will not be called as the watchers
548are destroyed before this cna happen (remember EV::check gets called
549first).
550
551The C<check_ns> variant doesn't start (activate) the newly created watcher.
206 552
207=back 553=back
208 554
209=head1 BUGS 555=head1 THREADS
210 556
211Lots. Libevent itself isn't well tested and rather buggy, and this module 557Threads are not supported by this module in any way. Perl pseudo-threads
212is quite new at the moment. 558is evil stuff and must die. As soon as Perl gains real threads I will work
559on thread support for it.
213 560
214Please note that the epoll method is not, in general, reliable in 561=head1 FORK
215programs that use fork (even if no libveent calls are being made in the 562
216forked process). Since this is such a common issue, this module will 563Most of the "improved" event delivering mechanisms of modern operating
217force the epoll method in EV to be off *unless* the global variable 564systems have quite a few problems with fork(2) (to put it bluntly: it is
218$EV::ENABLE_EPOLL is set to 1 *before* loading this module for the first 565not supported and usually destructive). Libev makes it possible to work
219time. 566around this by having a function that recreates the kernel state after
567fork in the child.
568
569On non-win32 platforms, this module requires the pthread_atfork
570functionality to do this automatically for you. This function is quite
571buggy on most BSDs, though, so YMMV. The overhead for this is quite
572negligible, because everything the function currently does is set a flag
573that is checked only when the event loop gets used the next time, so when
574you do fork but not use EV, the overhead is minimal.
575
576On win32, there is no notion of fork so all this doesn't apply, of course.
220 577
221=cut 578=cut
222 579
223our $NPRI = 4; 580our $DIED = sub {
224our $BASE; 581 warn "EV: error in callback (ignoring): $@";
225our $ENABLE_EPOLL; 582};
226 583
227{ 584default_loop
228 local $ENV{EVENT_NOEPOLL}; 585 or die 'EV: cannot initialise libev backend. bad $ENV{LIBEV_METHODS}?';
229 $ENV{EVENT_NOEPOLL} = 1 unless $ENABLE_EPOLL;
230 $BASE = init;
231}
232
233priority_init $NPRI;
234
235push @AnyEvent::REGISTRY, [EV => "EV::AnyEvent"];
236 586
2371; 5871;
238 588
239=head1 SEE ALSO 589=head1 SEE ALSO
240 590
241 L<EV::DNS>, L<event(3)>, L<event.h>, L<evdns.h>. 591 L<EV::DNS>.
242 L<EV::AnyEvent>.
243 592
244=head1 AUTHOR 593=head1 AUTHOR
245 594
246 Marc Lehmann <schmorp@schmorp.de> 595 Marc Lehmann <schmorp@schmorp.de>
247 http://home.schmorp.de/ 596 http://home.schmorp.de/

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines