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

Comparing Coro/Coro.pm (file contents):
Revision 1.107 by root, Fri Jan 5 18:25:51 2007 UTC vs.
Revision 1.122 by root, Sat Apr 14 15:06:05 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 do the same as calling exit outside
191 191the coroutine. Likewise, when the coroutine dies, the program will exit,
192When the coroutine dies, the program will exit, just as in the main 192just as it would in the main program.
193program.
194 193
195 # create a new coroutine that just prints its arguments 194 # create a new coroutine that just prints its arguments
196 async { 195 async {
197 print "@_\n"; 196 print "@_\n";
198 } 1,2,3,4; 197 } 1,2,3,4;
… …
210Similar to C<async>, but uses a coroutine pool, so you should not call 209Similar 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 210terminate 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 :). 211that might have executed other code already (which can be good or bad :).
213 212
214Also, the block is executed in an C<eval> context and a warning will be 213Also, 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. 214issued in case of an exception instead of terminating the program, as
215C<async> does. As the coroutine is being reused, stuff like C<on_destroy>
216will not work in the expected way, unless you call terminate or cancel,
217which somehow defeats the purpose of pooling.
216 218
217The priority will be reset to C<0> after each job, otherwise the coroutine 219The priority will be reset to C<0> after each job, otherwise the coroutine
218will be re-used "as-is". 220will be re-used "as-is".
219 221
220The pool size is limited to 8 idle coroutines (this can be adjusted by 222The pool size is limited to 8 idle coroutines (this can be adjusted by
… …
230our $POOL_SIZE = 8; 232our $POOL_SIZE = 8;
231our @pool; 233our @pool;
232 234
233sub pool_handler { 235sub pool_handler {
234 while () { 236 while () {
235 my ($cb, @arg) = @{ delete $current->{_invoke} };
236
237 eval { 237 eval {
238 my ($cb, @arg) = @{ delete $current->{_invoke} or return };
238 $cb->(@arg); 239 $cb->(@arg);
239 }; 240 };
240 warn $@ if $@; 241 warn $@ if $@;
241 242
242 last if @pool >= $POOL_SIZE; 243 last if @pool >= $POOL_SIZE;
243 push @pool, $current; 244 push @pool, $current;
244 245
246 $current->save (Coro::State::SAVE_DEF);
245 $current->prio (0); 247 $current->prio (0);
246 schedule; 248 schedule;
247 } 249 }
248} 250}
249 251
… …
323Create a new coroutine and return it. When the sub returns the coroutine 325Create a new coroutine and return it. When the sub returns the coroutine
324automatically terminates as if C<terminate> with the returned values were 326automatically terminates as if C<terminate> with the returned values were
325called. To make the coroutine run you must first put it into the ready queue 327called. To make the coroutine run you must first put it into the ready queue
326by calling the ready method. 328by calling the ready method.
327 329
328Calling C<exit> in a coroutine will not work correctly, so do not do that. 330See C<async> for additional discussion.
329 331
330=cut 332=cut
331 333
332sub _run_coro { 334sub _run_coro {
333 terminate &{+shift}; 335 terminate &{+shift};
… …
463and C<schedule> would cause a deadlock unless there is an idle handler 465and C<schedule> would cause a deadlock unless there is an idle handler
464that wakes up some coroutines. 466that wakes up some coroutines.
465 467
466=item my $guard = Coro::guard { ... } 468=item my $guard = Coro::guard { ... }
467 469
468This creates and returns a guard object. Nothing happens until the objetc 470This creates and returns a guard object. Nothing happens until the object
469gets destroyed, in which case the codeblock given as argument will be 471gets destroyed, in which case the codeblock given as argument will be
470executed. This is useful to free locks or other resources in case of a 472executed. This is useful to free locks or other resources in case of a
471runtime error or when the coroutine gets canceled, as in both cases the 473runtime error or when the coroutine gets canceled, as in both cases the
472guard block will be executed. The guard object supports only one method, 474guard block will be executed. The guard object supports only one method,
473C<< ->cancel >>, which will keep the codeblock from being executed. 475C<< ->cancel >>, which will keep the codeblock from being executed.

Diff Legend

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