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

Comparing Coro/Coro.pm (file contents):
Revision 1.194 by root, Tue Jul 8 20:08:40 2008 UTC vs.
Revision 1.206 by root, Thu Oct 30 09:57:00 2008 UTC

… …
16 cede; # yield to coroutine 16 cede; # yield to coroutine
17 print "3\n"; 17 print "3\n";
18 cede; # and again 18 cede; # and again
19 19
20 # use locking 20 # use locking
21 use Coro::Semaphore;
21 my $lock = new Coro::Semaphore; 22 my $lock = new Coro::Semaphore;
22 my $locked; 23 my $locked;
23 24
24 $lock->down; 25 $lock->down;
25 $locked = 1; 26 $locked = 1;
… …
66 67
67our $idle; # idle handler 68our $idle; # idle handler
68our $main; # main coroutine 69our $main; # main coroutine
69our $current; # current coroutine 70our $current; # current coroutine
70 71
71our $VERSION = 4.744; 72our $VERSION = 4.802;
72 73
73our @EXPORT = qw(async async_pool cede schedule terminate current unblock_sub); 74our @EXPORT = qw(async async_pool cede schedule terminate current unblock_sub);
74our %EXPORT_TAGS = ( 75our %EXPORT_TAGS = (
75 prio => [qw(PRIO_MAX PRIO_HIGH PRIO_NORMAL PRIO_LOW PRIO_IDLE PRIO_MIN)], 76 prio => [qw(PRIO_MAX PRIO_HIGH PRIO_NORMAL PRIO_LOW PRIO_IDLE PRIO_MIN)],
76); 77);
… …
81=item $Coro::main 82=item $Coro::main
82 83
83This variable stores the coroutine object that represents the main 84This variable stores the coroutine object that represents the main
84program. While you cna C<ready> it and do most other things you can do to 85program. While you cna C<ready> it and do most other things you can do to
85coroutines, it is mainly useful to compare again C<$Coro::current>, to see 86coroutines, it is mainly useful to compare again C<$Coro::current>, to see
86wether you are running in the main program or not. 87whether you are running in the main program or not.
87 88
88=cut 89=cut
89 90
90$main = new Coro; 91$main = new Coro;
91 92
… …
220terminate or join on it (although you are allowed to), and you get a 221terminate or join on it (although you are allowed to), and you get a
221coroutine that might have executed other code already (which can be good 222coroutine that might have executed other code already (which can be good
222or bad :). 223or bad :).
223 224
224On the plus side, this function is faster than creating (and destroying) 225On the plus side, this function is faster than creating (and destroying)
225a completely new coroutine, so if you need a lot of generic coroutines in 226a completly new coroutine, so if you need a lot of generic coroutines in
226quick successsion, use C<async_pool>, not C<async>. 227quick successsion, use C<async_pool>, not C<async>.
227 228
228The code block is executed in an C<eval> context and a warning will be 229The code block is executed in an C<eval> context and a warning will be
229issued in case of an exception instead of terminating the program, as 230issued in case of an exception instead of terminating the program, as
230C<async> does. As the coroutine is being reused, stuff like C<on_destroy> 231C<async> does. As the coroutine is being reused, stuff like C<on_destroy>
… …
234 235
235The priority will be reset to C<0> after each run, tracing will be 236The priority will be reset to C<0> after each run, tracing will be
236disabled, the description will be reset and the default output filehandle 237disabled, the description will be reset and the default output filehandle
237gets restored, so you can change all these. Otherwise the coroutine will 238gets restored, so you can change all these. Otherwise the coroutine will
238be re-used "as-is": most notably if you change other per-coroutine global 239be re-used "as-is": most notably if you change other per-coroutine global
239stuff such as C<$/> you I<must needs> to revert that change, which is most 240stuff such as C<$/> you I<must needs> revert that change, which is most
240simply done by using local as in: C< local $/ >. 241simply done by using local as in: C<< local $/ >>.
241 242
242The pool size is limited to C<8> idle coroutines (this can be adjusted by 243The idle pool size is limited to C<8> idle coroutines (this can be
243changing $Coro::POOL_SIZE), and there can be as many non-idle coros as 244adjusted by changing $Coro::POOL_SIZE), but there can be as many non-idle
244required. 245coros as required.
245 246
246If you are concerned about pooled coroutines growing a lot because a 247If you are concerned about pooled coroutines growing a lot because a
247single C<async_pool> used a lot of stackspace you can e.g. C<async_pool 248single C<async_pool> used a lot of stackspace you can e.g. C<async_pool
248{ terminate }> once per second or so to slowly replenish the pool. In 249{ terminate }> once per second or so to slowly replenish the pool. In
249addition to that, when the stacks used by a handler grows larger than 16kb 250addition to that, when the stacks used by a handler grows larger than 16kb
… …
309This makes C<schedule> I<the> generic method to use to block the current 310This makes C<schedule> I<the> generic method to use to block the current
310coroutine and wait for events: first you remember the current coroutine in 311coroutine and wait for events: first you remember the current coroutine in
311a variable, then arrange for some callback of yours to call C<< ->ready 312a variable, then arrange for some callback of yours to call C<< ->ready
312>> on that once some event happens, and last you call C<schedule> to put 313>> on that once some event happens, and last you call C<schedule> to put
313yourself to sleep. Note that a lot of things can wake your coroutine up, 314yourself to sleep. Note that a lot of things can wake your coroutine up,
314so you need to check wether the event indeed happened, e.g. by storing the 315so you need to check whether the event indeed happened, e.g. by storing the
315status in a variable. 316status in a variable.
316 317
317The canonical way to wait on external events is this: 318The canonical way to wait on external events is this:
318 319
319 { 320 {
… …
358Kills/terminates/cancels all coroutines except the currently running 359Kills/terminates/cancels all coroutines except the currently running
359one. This is useful after a fork, either in the child or the parent, as 360one. This is useful after a fork, either in the child or the parent, as
360usually only one of them should inherit the running coroutines. 361usually only one of them should inherit the running coroutines.
361 362
362Note that while this will try to free some of the main programs resources, 363Note that while this will try to free some of the main programs resources,
363you cnanot free all of them, so if a coroutine that is not the main 364you cannot free all of them, so if a coroutine that is not the main
364program calls this function, there will be some one-time resource leak. 365program calls this function, there will be some one-time resource leak.
365 366
366=cut 367=cut
367 368
368sub terminate { 369sub terminate {
… …
417once all the coroutines of higher priority and all coroutines of the same 418once all the coroutines of higher priority and all coroutines of the same
418priority that were put into the ready queue earlier have been resumed. 419priority that were put into the ready queue earlier have been resumed.
419 420
420=item $is_ready = $coroutine->is_ready 421=item $is_ready = $coroutine->is_ready
421 422
422Return wether the coroutine is currently the ready queue or not, 423Return whether the coroutine is currently the ready queue or not,
423 424
424=item $coroutine->cancel (arg...) 425=item $coroutine->cancel (arg...)
425 426
426Terminates the given coroutine and makes it return the given arguments as 427Terminates the given coroutine and makes it return the given arguments as
427status (default: the empty list). Never returns if the coroutine is the 428status (default: the empty list). Never returns if the coroutine is the

Diff Legend

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