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

Comparing EV/README (file contents):
Revision 1.5 by root, Thu Nov 1 13:33:12 2007 UTC vs.
Revision 1.10 by root, Wed Nov 14 21:25:46 2007 UTC

1NAME 1NAME
2 EV - perl interface to libevent, monkey.org/~provos/libevent/ 2 EV - perl interface to libev, a high performance full-featured event
3 loop
3 4
4SYNOPSIS 5SYNOPSIS
5 use EV; 6 use EV;
6 7
7 # TIMER 8 # TIMERS
8 9
9 my $w = EV::timer 2, 0, sub { 10 my $w = EV::timer 2, 0, sub {
10 warn "is called after 2s"; 11 warn "is called after 2s";
11 }; 12 };
12 13
13 my $w = EV::timer 2, 1, sub { 14 my $w = EV::timer 2, 2, sub {
14 warn "is called roughly every 2s (repeat = 1)"; 15 warn "is called roughly every 2s (repeat = 2)";
15 }; 16 };
16 17
17 undef $w; # destroy event watcher again 18 undef $w; # destroy event watcher again
18 19
19 my $w = EV::timer_abs 0, 60, sub { 20 my $w = EV::periodic 0, 60, 0, sub {
20 warn "is called every minute, on the minute, exactly"; 21 warn "is called every minute, on the minute, exactly";
21 }; 22 };
22 23
23 # IO 24 # IO
24 25
25 my $w = EV::io \*STDIN, EV::READ | EV::PERSIST, sub { 26 my $w = EV::io *STDIN, EV::READ, sub {
26 my ($w, $revents) = @_; # all callbacks get the watcher object and event mask 27 my ($w, $revents) = @_; # all callbacks receive the watcher and event mask
27 if ($revents & EV::TIMEOUT) {
28 warn "nothing received on stdin for 10 seconds, retrying";
29 } else {
30 warn "stdin is readable, you entered: ", <STDIN>; 28 warn "stdin is readable, you entered: ", <STDIN>;
31 }
32 };
33 $w->timeout (10);
34
35 my $w = EV::timed_io \*STDIN, EV::READ, 30, sub {
36 my ($w, $revents) = @_;
37 if ($revents & EV::TIMEOUT) {
38 warn "nothing entered within 30 seconds, bye bye.\n";
39 $w->stop;
40 } else {
41 my $line = <STDIN>;
42 warn "you entered something, you again have 30 seconds.\n";
43 }
44 }; 29 };
45 30
46 # SIGNALS 31 # SIGNALS
47 32
48 my $w = EV::signal 'QUIT', sub { 33 my $w = EV::signal 'QUIT', sub {
49 warn "sigquit received\n"; 34 warn "sigquit received\n";
50 }; 35 };
51 36
52 my $w = EV::signal 3, sub {
53 warn "sigquit received (this is GNU/Linux, right?)\n";
54 };
55
56 # CHILD/PID STATUS CHANGES 37 # CHILD/PID STATUS CHANGES
57 38
58 my $w = EV::child 666, sub { 39 my $w = EV::child 666, sub {
59 my ($w, $revents, $status) = @_; 40 my ($w, $revents) = @_;
41 my $status = $w->rstatus;
60 }; 42 };
61 43
62 # MAINLOOP 44 # MAINLOOP
63 EV::dispatch; # loop as long as watchers are active 45 EV::loop; # loop until EV::unloop is called or all watchers stop
64 EV::loop; # the same thing
65 EV::loop EV::LOOP_ONESHOT; # block until some events could be handles 46 EV::loop EV::LOOP_ONESHOT; # block until at least one event could be handled
66 EV::loop EV::LOOP_NONBLOCK; # check and handle some events, but do not wait 47 EV::loop EV::LOOP_NONBLOCK; # try to handle same events, but do not block
67 48
68DESCRIPTION 49DESCRIPTION
69 This module provides an interface to libev 50 This module provides an interface to libev
70 (<http://software.schmorp.de/pkg/libev.html>). You probably should 51 (<http://software.schmorp.de/pkg/libev.html>).
71 acquaint yourself with its documentation and source code to be able to
72 use this module fully.
73 52
74BASIC INTERFACE 53BASIC INTERFACE
75 $EV::NPRI
76 How many priority levels are available.
77
78 $EV::DIED 54 $EV::DIED
79 Must contain a reference to a function that is called when a 55 Must contain a reference to a function that is called when a
80 callback throws an exception (with $@ containing thr error). The 56 callback throws an exception (with $@ containing thr error). The
81 default prints an informative message and continues. 57 default prints an informative message and continues.
82 58
83 If this callback throws an exception it will be silently ignored. 59 If this callback throws an exception it will be silently ignored.
84 60
61 $time = EV::time
62 Returns the current time in (fractional) seconds since the epoch.
63
85 $time = EV::now 64 $time = EV::now
86 Returns the time in (fractional) seconds since the epoch. 65 Returns the time the last event loop iteration has been started.
66 This is the time that (relative) timers are based on, and refering
67 to it is usually faster then calling EV::time.
87 68
88 $version = EV::version
89 $method = EV::method 69 $method = EV::ev_method
90 Return version string and event polling method used. 70 Returns an integer describing the backend used by libev
71 (EV::METHOD_SELECT or EV::METHOD_EPOLL).
91 72
92 EV::loop $flags # EV::LOOP_ONCE, EV::LOOP_ONESHOT 73 EV::loop [$flags]
93 EV::loopexit $after 74 Begin checking for events and calling callbacks. It returns when a
94 Exit any active loop or dispatch after $after seconds or immediately 75 callback calls EV::unloop.
95 if $after is missing or zero.
96 76
97 EV::dispatch 77 The $flags argument can be one of the following:
98 Same as "EV::loop 0".
99 78
100 EV::event $callback 79 0 as above
101 Creates a new event watcher waiting for nothing, calling the given 80 EV::LOOP_ONESHOT block at most once (wait, but do not loop)
102 callback. 81 EV::LOOP_NONBLOCK do not block at all (fetch/handle events but do not wait)
103 82
83 EV::unloop [$how]
84 When called with no arguments or an argument of EV::UNLOOP_ONE,
85 makes the innermost call to EV::loop return.
86
87 When called with an argument of EV::UNLOOP_ALL, all calls to
88 EV::loop will return as fast as possible.
89
90 WATCHER
91 A watcher is an object that gets created to record your interest in some
92 event. For instance, if you want to wait for STDIN to become readable,
93 you would create an EV::io watcher for that:
94
95 my $watcher = EV::io *STDIN, EV::READ, sub {
96 my ($watcher, $revents) = @_;
97 warn "yeah, STDIN should not be readable without blocking!\n"
98 };
99
100 All watchers can be active (waiting for events) or inactive (paused).
101 Only active watchers will have their callbacks invoked. All callbacks
102 will be called with at least two arguments: the watcher and a bitmask of
103 received events.
104
105 Each watcher type has its associated bit in revents, so you can use the
106 same callback for multiple watchers. The event mask is named after the
107 type, i..e. EV::child sets EV::CHILD, EV::prepare sets EV::PREPARE,
108 EV::periodic sets EV::PERIODIC and so on, with the exception of IO
109 events (which can set both EV::READ and EV::WRITE bits), and EV::timer
110 (which uses EV::TIMEOUT).
111
112 In the rare case where one wants to create a watcher but not start it at
113 the same time, each constructor has a variant with a trailing "_ns" in
114 its name, e.g. EV::io has a non-starting variant EV::io_ns and so on.
115
116 Please note that a watcher will automatically be stopped when the
117 watcher object is destroyed, so you *need* to keep the watcher objects
118 returned by the constructors.
119
120 Also, all methods changing some aspect of a watcher (->set, ->priority,
121 ->fh and so on) automatically stop and start it again if it is active,
122 which means pending events get lost.
123
124 WATCHER TYPES
125 Now lets move to the existing watcher types and asociated methods.
126
127 The following methods are available for all watchers. Then followes a
128 description of each watcher constructor (EV::io, EV::timer,
129 EV::periodic, EV::signal, EV::child, EV::idle, EV::prepare and
130 EV::check), followed by any type-specific methods (if any).
131
132 $w->start
133 Starts a watcher if it isn't active already. Does nothing to an
134 already active watcher. By default, all watchers start out in the
135 active state (see the description of the "_ns" variants if you need
136 stopped watchers).
137
138 $w->stop
139 Stop a watcher if it is active. Also clear any pending events
140 (events that have been received but that didn't yet result in a
141 callback invocation), regardless of wether the watcher was active or
142 not.
143
144 $bool = $w->is_active
145 Returns true if the watcher is active, false otherwise.
146
147 $current_data = $w->data
148 $old_data = $w->data ($new_data)
149 Queries a freely usable data scalar on the watcher and optionally
150 changes it. This is a way to associate custom data with a watcher:
151
152 my $w = EV::timer 60, 0, sub {
153 warn $_[0]->data;
154 };
155 $w->data ("print me!");
156
157 $current_cb = $w->cb
158 $old_cb = $w->cb ($new_cb)
159 Queries the callback on the watcher and optionally changes it. You
160 can do this at any time without the watcher restarting.
161
162 $current_priority = $w->priority
163 $old_priority = $w->priority ($new_priority)
164 Queries the priority on the watcher and optionally changes it.
165 Pending watchers with higher priority will be invoked first. The
166 valid range of priorities lies between EV::MAXPRI (default 2) and
167 EV::MINPRI (default -2). If the priority is outside this range it
168 will automatically be normalised to the nearest valid priority.
169
170 The default priority of any newly-created weatcher is 0.
171
172 $w->trigger ($revents)
173 Call the callback *now* with the given event mask.
174
104 my $w = EV::io $fileno_or_fh, $eventmask, $callback 175 $w = EV::io $fileno_or_fh, $eventmask, $callback
105 my $w = EV::io_ns $fileno_or_fh, $eventmask, $callback 176 $w = EV::io_ns $fileno_or_fh, $eventmask, $callback
106 As long as the returned watcher object is alive, call the $callback 177 As long as the returned watcher object is alive, call the $callback
107 when the events specified in $eventmask happen. Initially, the 178 when the events specified in $eventmask.
108 timeout is disabled.
109 179
110 You can additionall set a timeout to occur on the watcher, but note
111 that this timeout will not be reset when you get an I/O event in the
112 EV::PERSIST case, and reaching a timeout will always stop the
113 watcher even in the EV::PERSIST case.
114
115 If you want a timeout to occur only after a specific time of
116 inactivity, set a repeating timeout and do NOT use EV::PERSIST.
117
118 Eventmask can be one or more of these constants ORed together: 180 The $eventmask can be one or more of these constants ORed together:
119 181
120 EV::READ wait until read() wouldn't block anymore 182 EV::READ wait until read() wouldn't block anymore
121 EV::WRITE wait until write() wouldn't block anymore 183 EV::WRITE wait until write() wouldn't block anymore
122 EV::PERSIST stay active after a (non-timeout) event occured
123 184
124 The "io_ns" variant doesn't add/start the newly created watcher. 185 The "io_ns" variant doesn't start (activate) the newly created
125
126 my $w = EV::timed_io $fileno_or_fh, $eventmask, $timeout, $callback
127 my $w = EV::timed_io_ns $fileno_or_fh, $eventmask, $timeout, $callback
128 Same as "io" and "io_ns", but also specifies a timeout (as if there
129 was a call to "$w->timeout ($timout, 1)". The persist flag is not
130 allowed and will automatically be cleared. The watcher will be
131 restarted after each event.
132
133 If the timeout is zero or undef, no timeout will be set, and a
134 normal watcher (with the persist flag set!) will be created.
135
136 This has the effect of timing out after the specified period of
137 inactivity has happened.
138
139 Due to the design of libevent, this is also relatively inefficient,
140 having one or two io watchers and a separate timeout watcher that
141 you reset on activity (by calling its "start" method) is usually
142 more efficient.
143
144 my $w = EV::timer $after, $repeat, $callback
145 my $w = EV::timer_ns $after, $repeat, $callback
146 Calls the callback after $after seconds. If $repeat is true, the
147 timer will be restarted after the callback returns. This means that
148 the callback would be called roughly every $after seconds, prolonged
149 by the time the callback takes.
150
151 The "timer_ns" variant doesn't add/start the newly created watcher.
152
153 my $w = EV::timer_abs $at, $interval, $callback
154 my $w = EV::timer_abs_ns $at, $interval, $callback
155 Similar to EV::timer, but the time is given as an absolute point in
156 time ($at), plus an optional $interval.
157
158 If the $interval is zero, then the callback will be called at the
159 time $at if that is in the future, or as soon as possible if its in
160 the past. It will not automatically repeat.
161
162 If the $interval is nonzero, then the watcher will always be
163 scheduled to time out at the next "$at + integer * $interval" time.
164
165 This can be used to schedule a callback to run at very regular
166 intervals, as long as the processing time is less then the interval
167 (otherwise obviously events will be skipped).
168
169 Another way to think about it (for the mathematically inclined) is
170 that "timer_abs" will try to tun the callback at the next possible
171 time where "$time = $at (mod $interval)", regardless of any time
172 jumps.
173
174 The "timer_abs_ns" variant doesn't add/start the newly created
175 watcher. 186 watcher.
176 187
177 my $w = EV::signal $signal, $callback 188 $w->set ($fileno_or_fh, $eventmask)
178 my $w = EV::signal_ns $signal, $callback 189 Reconfigures the watcher, see the constructor above for details. Can
179 Call the callback when $signal is received (the signal can be 190 be called at any time.
180 specified by number or by name, just as with kill or %SIG). Signal
181 watchers are persistent no natter what.
182
183 EV will grab the signal for the process (the kernel only allows one
184 component to receive signals) when you start a signal watcher, and
185 removes it again when you stop it. Pelr does the same when you
186 add/remove callbacks to %SIG, so watch out.
187
188 Unfortunately, only one handler can be registered per signal. Screw
189 libevent.
190
191 The "signal_ns" variant doesn't add/start the newly created watcher.
192
193THE EV::Event CLASS
194 All EV functions creating an event watcher (designated by "my $w ="
195 above) support the following methods on the returned watcher object:
196
197 $w->add ($timeout)
198 Stops and (re-)starts the event watcher, setting the optional
199 timeout to the given value, or clearing the timeout if none is
200 given.
201
202 $w->start
203 Stops and (re-)starts the event watcher without touching the
204 timeout.
205
206 $w->del
207 $w->stop
208 Stop the event watcher if it was started.
209
210 $current_callback = $w->cb
211 $old_callback = $w->cb ($new_callback)
212 Return the previously set callback and optionally set a new one.
213 191
214 $current_fh = $w->fh 192 $current_fh = $w->fh
215 $old_fh = $w->fh ($new_fh) 193 $old_fh = $w->fh ($new_fh)
216 Returns the previously set filehandle and optionally set a new one 194 Returns the previously set filehandle and optionally set a new one.
217 (also clears the EV::SIGNAL flag when setting a filehandle).
218
219 $current_signal = $w->signal
220 $old_signal = $w->signal ($new_signal)
221 Returns the previously set signal number and optionally set a new
222 one (also sets the EV::SIGNAL flag when setting a signal).
223 195
224 $current_eventmask = $w->events 196 $current_eventmask = $w->events
225 $old_eventmask = $w->events ($new_eventmask) 197 $old_eventmask = $w->events ($new_eventmask)
226 Returns the previously set event mask and optionally set a new one. 198 Returns the previously set event mask and optionally set a new one.
227 199
200 $w = EV::timer $after, $repeat, $callback
201 $w = EV::timer_ns $after, $repeat, $callback
202 Calls the callback after $after seconds. If $repeat is non-zero, the
203 timer will be restarted (with the $repeat value as $after) after the
204 callback returns.
205
206 This means that the callback would be called roughly after $after
207 seconds, and then every $repeat seconds. The timer does his best not
208 to drift, but it will not invoke the timer more often then once per
209 event loop iteration, and might drift in other cases. If that isn't
210 acceptable, look at EV::periodic, which can provide long-term stable
211 timers.
212
213 The timer is based on a monotonic clock, that is, if somebody is
214 sitting in front of the machine while the timer is running and
215 changes the system clock, the timer will nevertheless run (roughly)
216 the same time.
217
218 The "timer_ns" variant doesn't start (activate) the newly created
219 watcher.
220
228 $w->timeout ($after, $repeat) 221 $w->set ($after, $repeat)
229 Resets the timeout (see "EV::timer" for details). 222 Reconfigures the watcher, see the constructor above for details. Can
223 be at any time.
230 224
231 $w->timeout_abs ($at, $interval) 225 $w->again
232 Resets the timeout (see "EV::timer_abs" for details). 226 Similar to the "start" method, but has special semantics for
227 repeating timers:
233 228
234 $w->priority_set ($priority) 229 If the timer is active and non-repeating, it will be stopped.
235 Set the priority of the watcher to $priority (0 <= $priority < 230
236 $EV::NPRI). 231 If the timer is active and repeating, reset the timeout to occur
232 $repeat seconds after now.
233
234 If the timer is inactive and repeating, start it using the repeat
235 value.
236
237 Otherwise do nothing.
238
239 This behaviour is useful when you have a timeout for some IO
240 operation. You create a timer object with the same value for $after
241 and $repeat, and then, in the read/write watcher, run the "again"
242 method on the timeout.
243
244 $w = EV::periodic $at, $interval, $reschedule_cb, $callback
245 $w = EV::periodic_ns $at, $interval, $reschedule_cb, $callback
246 Similar to EV::timer, but is not based on relative timeouts but on
247 absolute times. Apart from creating "simple" timers that trigger
248 "at" the specified time, it can also be used for non-drifting
249 absolute timers and more complex, cron-like, setups that are not
250 adversely affected by time jumps (i.e. when the system clock is
251 changed by explicit date -s or other means such as ntpd). It is also
252 the most complex watcher type in EV.
253
254 It has three distinct "modes":
255
256 * absolute timer ($interval = $reschedule_cb = 0)
257 This time simply fires at the wallclock time $at and doesn't
258 repeat. It will not adjust when a time jump occurs, that is, if
259 it is to be run at January 1st 2011 then it will run when the
260 system time reaches or surpasses this time.
261
262 * non-repeating interval timer ($interval > 0, $reschedule_cb = 0)
263 In this mode the watcher will always be scheduled to time out at
264 the next "$at + N * $interval" time (for some integer N) and
265 then repeat, regardless of any time jumps.
266
267 This can be used to create timers that do not drift with respect
268 to system time:
269
270 my $hourly = EV::periodic 0, 3600, 0, sub { print "once/hour\n" };
271
272 That doesn't mean there will always be 3600 seconds in between
273 triggers, but only that the the clalback will be called when the
274 system time shows a full hour (UTC).
275
276 Another way to think about it (for the mathematically inclined)
277 is that EV::periodic will try to run the callback in this mode
278 at the next possible time where "$time = $at (mod $interval)",
279 regardless of any time jumps.
280
281 * manual reschedule mode ($reschedule_cb = coderef)
282 In this mode $interval and $at are both being ignored. Instead,
283 each time the periodic watcher gets scheduled, the reschedule
284 callback ($reschedule_cb) will be called with the watcher as
285 first, and the current time as second argument.
286
287 *This callback MUST NOT stop or destroy this or any other
288 periodic watcher, ever*. If you need to stop it, return 1e30 and
289 stop it afterwards.
290
291 It must return the next time to trigger, based on the passed
292 time value (that is, the lowest time value larger than to the
293 second argument). It will usually be called just before the
294 callback will be triggered, but might be called at other times,
295 too.
296
297 This can be used to create very complex timers, such as a timer
298 that triggers on each midnight, local time (actually 24 hours
299 after the last midnight, to keep the example simple. If you know
300 a way to do it correctly in about the same space (without
301 requiring elaborate modules), drop me a note :):
302
303 my $daily = EV::periodic 0, 0, sub {
304 my ($w, $now) = @_;
305
306 use Time::Local ();
307 my (undef, undef, undef, $d, $m, $y) = localtime $now;
308 86400 + Time::Local::timelocal 0, 0, 0, $d, $m, $y
309 }, sub {
310 print "it's midnight or likely shortly after, now\n";
311 };
312
313 The "periodic_ns" variant doesn't start (activate) the newly created
314 watcher.
315
316 $w->set ($at, $interval, $reschedule_cb)
317 Reconfigures the watcher, see the constructor above for details. Can
318 be at any time.
319
320 $w->again
321 Simply stops and starts the watcher again.
322
323 $w = EV::signal $signal, $callback
324 $w = EV::signal_ns $signal, $callback
325 Call the callback when $signal is received (the signal can be
326 specified by number or by name, just as with kill or %SIG).
327
328 EV will grab the signal for the process (the kernel only allows one
329 component to receive a signal at a time) when you start a signal
330 watcher, and removes it again when you stop it. Perl does the same
331 when you add/remove callbacks to %SIG, so watch out.
332
333 You can have as many signal watchers per signal as you want.
334
335 The "signal_ns" variant doesn't start (activate) the newly created
336 watcher.
337
338 $w->set ($signal)
339 Reconfigures the watcher, see the constructor above for details. Can
340 be at any time.
341
342 $current_signum = $w->signal
343 $old_signum = $w->signal ($new_signal)
344 Returns the previously set signal (always as a number not name) and
345 optionally set a new one.
346
347 $w = EV::child $pid, $callback
348 $w = EV::child_ns $pid, $callback
349 Call the callback when a status change for pid $pid (or any pid if
350 $pid is 0) has been received. More precisely: when the process
351 receives a SIGCHLD, EV will fetch the outstanding exit/wait status
352 for all changed/zombie children and call the callback.
353
354 You can access both status and pid by using the "rstatus" and "rpid"
355 methods on the watcher object.
356
357 You can have as many pid watchers per pid as you want.
358
359 The "child_ns" variant doesn't start (activate) the newly created
360 watcher.
361
362 $w->set ($pid)
363 Reconfigures the watcher, see the constructor above for details. Can
364 be at any time.
365
366 $current_pid = $w->pid
367 $old_pid = $w->pid ($new_pid)
368 Returns the previously set process id and optionally set a new one.
369
370 $exit_status = $w->rstatus
371 Return the exit/wait status (as returned by waitpid, see the waitpid
372 entry in perlfunc).
373
374 $pid = $w->rpid
375 Return the pid of the awaited child (useful when you have installed
376 a watcher for all pids).
377
378 $w = EV::idle $callback
379 $w = EV::idle_ns $callback
380 Call the callback when there are no pending io, timer/periodic,
381 signal or child events, i.e. when the process is idle.
382
383 The process will not block as long as any idle watchers are active,
384 and they will be called repeatedly until stopped.
385
386 The "idle_ns" variant doesn't start (activate) the newly created
387 watcher.
388
389 $w = EV::prepare $callback
390 $w = EV::prepare_ns $callback
391 Call the callback just before the process would block. You can still
392 create/modify any watchers at this point.
393
394 See the EV::check watcher, below, for explanations and an example.
395
396 The "prepare_ns" variant doesn't start (activate) the newly created
397 watcher.
398
399 $w = EV::check $callback
400 $w = EV::check_ns $callback
401 Call the callback just after the process wakes up again (after it
402 has gathered events), but before any other callbacks have been
403 invoked.
404
405 This is used to integrate other event-based software into the EV
406 mainloop: You register a prepare callback and in there, you create
407 io and timer watchers as required by the other software. Here is a
408 real-world example of integrating Net::SNMP (with some details left
409 out):
410
411 our @snmp_watcher;
412
413 our $snmp_prepare = EV::prepare sub {
414 # do nothing unless active
415 $dispatcher->{_event_queue_h}
416 or return;
417
418 # make the dispatcher handle any outstanding stuff
419
420 # create an IO watcher for each and every socket
421 @snmp_watcher = (
422 (map { EV::io $_, EV::READ, sub { } }
423 keys %{ $dispatcher->{_descriptors} }),
424 );
425
426 # if there are any timeouts, also create a timer
427 push @snmp_watcher, EV::timer $event->[Net::SNMP::Dispatcher::_TIME] - EV::now, 0, sub { }
428 if $event->[Net::SNMP::Dispatcher::_ACTIVE];
429 };
430
431 The callbacks are irrelevant, the only purpose of those watchers is
432 to wake up the process as soon as one of those events occurs (socket
433 readable, or timer timed out). The corresponding EV::check watcher
434 will then clean up:
435
436 our $snmp_check = EV::check sub {
437 # destroy all watchers
438 @snmp_watcher = ();
439
440 # make the dispatcher handle any new stuff
441 };
442
443 The callbacks of the created watchers will not be called as the
444 watchers are destroyed before this cna happen (remember EV::check
445 gets called first).
446
447 The "check_ns" variant doesn't start (activate) the newly created
448 watcher.
237 449
238THREADS 450THREADS
239 Threads are not supported by this in any way. Perl pseudo-threads is 451 Threads are not supported by this in any way. Perl pseudo-threads is
240 evil and must die. 452 evil stuff and must die.
241 453
242SEE ALSO 454SEE ALSO
243 L<EV::DNS>, L<event(3)>, L<event.h>, L<evdns.h>.
244 L<EV::AnyEvent>. 455 L<EV::DNS>, L<EV::AnyEvent>.
245 456
246AUTHOR 457AUTHOR
247 Marc Lehmann <schmorp@schmorp.de> 458 Marc Lehmann <schmorp@schmorp.de>
248 http://home.schmorp.de/ 459 http://home.schmorp.de/
249 460

Diff Legend

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