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

Comparing Coro/Coro.pm (file contents):
Revision 1.106 by root, Fri Jan 5 17:44:17 2007 UTC vs.
Revision 1.121 by root, Fri Apr 13 12:56:55 2007 UTC

… …
50 50
51our $idle; # idle handler 51our $idle; # idle handler
52our $main; # main coroutine 52our $main; # main coroutine
53our $current; # current coroutine 53our $current; # current coroutine
54 54
55our $VERSION = '3.3'; 55our $VERSION = '3.56';
56 56
57our @EXPORT = qw(async async_pool cede schedule terminate current unblock_sub); 57our @EXPORT = qw(async async_pool cede schedule terminate current unblock_sub);
58our %EXPORT_TAGS = ( 58our %EXPORT_TAGS = (
59 prio => [qw(PRIO_MAX PRIO_HIGH PRIO_NORMAL PRIO_LOW PRIO_IDLE PRIO_MIN)], 59 prio => [qw(PRIO_MAX PRIO_HIGH PRIO_NORMAL PRIO_LOW PRIO_IDLE PRIO_MIN)],
60); 60);
… …
185 185
186Create a new asynchronous coroutine and return it's coroutine object 186Create a new asynchronous coroutine and return it's coroutine object
187(usually unused). When the sub returns the new coroutine is automatically 187(usually unused). When the sub returns the new coroutine is automatically
188terminated. 188terminated.
189 189
190Calling C<exit> in a coroutine will not work correctly, so do not do that. 190Calling C<exit> in a coroutine will try to do the same as calling exit
191outside the coroutine, but this is experimental. It is best not to rely on
192exit doing any cleanups or even not crashing.
191 193
192When the coroutine dies, the program will exit, just as in the main 194When the coroutine dies, the program will exit, just as in the main
193program. 195program.
194 196
195 # create a new coroutine that just prints its arguments 197 # create a new coroutine that just prints its arguments
… …
210Similar to C<async>, but uses a coroutine pool, so you should not call 212Similar to C<async>, but uses a coroutine pool, so you should not call
211terminate or join (although you are allowed to), and you get a coroutine 213terminate or join (although you are allowed to), and you get a coroutine
212that might have executed other code already (which can be good or bad :). 214that might have executed other code already (which can be good or bad :).
213 215
214Also, the block is executed in an C<eval> context and a warning will be 216Also, the block is executed in an C<eval> context and a warning will be
215issued in case of an exception instead of terminating the program, as C<async> does. 217issued in case of an exception instead of terminating the program, as
218C<async> does. As the coroutine is being reused, stuff like C<on_destroy>
219will not work in the expected way, unless you call terminate or cancel,
220which somehow defeats the purpose of pooling.
216 221
217The priority will be reset to C<0> after each job, otherwise the coroutine 222The priority will be reset to C<0> after each job, otherwise the coroutine
218will be re-used "as-is". 223will be re-used "as-is".
219 224
220The pool size is limited to 8 idle coroutines (this can be adjusted by 225The pool size is limited to 8 idle coroutines (this can be adjusted by
… …
230our $POOL_SIZE = 8; 235our $POOL_SIZE = 8;
231our @pool; 236our @pool;
232 237
233sub pool_handler { 238sub pool_handler {
234 while () { 239 while () {
235 my ($cb, @arg) = @{ delete $current->{_invoke} };
236
237 eval { 240 eval {
241 my ($cb, @arg) = @{ delete $current->{_invoke} or return };
238 $cb->(@arg); 242 $cb->(@arg);
239 }; 243 };
240 warn $@ if $@; 244 warn $@ if $@;
241 245
242 last if @pool >= $POOL_SIZE; 246 last if @pool >= $POOL_SIZE;
243 push @pool, $current; 247 push @pool, $current;
244 248
249 $current->save (Coro::State::SAVE_DEF);
245 $current->prio (0); 250 $current->prio (0);
246 schedule; 251 schedule;
247 } 252 }
248} 253}
249 254
… …
287 292
288"Cede" to other coroutines. This function puts the current coroutine into the 293"Cede" to other coroutines. This function puts the current coroutine into the
289ready queue and calls C<schedule>, which has the effect of giving up the 294ready queue and calls C<schedule>, which has the effect of giving up the
290current "timeslice" to other coroutines of the same or higher priority. 295current "timeslice" to other coroutines of the same or higher priority.
291 296
297Returns true if at least one coroutine switch has happened.
298
292=item Coro::cede_notself 299=item Coro::cede_notself
293 300
294Works like cede, but is not exported by default and will cede to any 301Works like cede, but is not exported by default and will cede to any
295coroutine, regardless of priority, once. 302coroutine, regardless of priority, once.
303
304Returns true if at least one coroutine switch has happened.
296 305
297=item terminate [arg...] 306=item terminate [arg...]
298 307
299Terminates the current coroutine with the given status values (see L<cancel>). 308Terminates the current coroutine with the given status values (see L<cancel>).
300 309
… …
319Create a new coroutine and return it. When the sub returns the coroutine 328Create a new coroutine and return it. When the sub returns the coroutine
320automatically terminates as if C<terminate> with the returned values were 329automatically terminates as if C<terminate> with the returned values were
321called. To make the coroutine run you must first put it into the ready queue 330called. To make the coroutine run you must first put it into the ready queue
322by calling the ready method. 331by calling the ready method.
323 332
324Calling C<exit> in a coroutine will not work correctly, so do not do that. 333See C<async> for additional discussion.
325 334
326=cut 335=cut
327 336
328sub _run_coro { 337sub _run_coro {
329 terminate &{+shift}; 338 terminate &{+shift};
… …
459and C<schedule> would cause a deadlock unless there is an idle handler 468and C<schedule> would cause a deadlock unless there is an idle handler
460that wakes up some coroutines. 469that wakes up some coroutines.
461 470
462=item my $guard = Coro::guard { ... } 471=item my $guard = Coro::guard { ... }
463 472
464This creates and returns a guard object. Nothing happens until the objetc 473This creates and returns a guard object. Nothing happens until the object
465gets destroyed, in which case the codeblock given as argument will be 474gets destroyed, in which case the codeblock given as argument will be
466executed. This is useful to free locks or other resources in case of a 475executed. This is useful to free locks or other resources in case of a
467runtime error or when the coroutine gets canceled, as in both cases the 476runtime error or when the coroutine gets canceled, as in both cases the
468guard block will be executed. The guard object supports only one method, 477guard block will be executed. The guard object supports only one method,
469C<< ->cancel >>, which will keep the codeblock from being executed. 478C<< ->cancel >>, which will keep the codeblock from being executed.

Diff Legend

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