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

Comparing Coro/Coro.pm (file contents):
Revision 1.224 by root, Wed Nov 19 05:52:42 2008 UTC vs.
Revision 1.233 by root, Fri Nov 21 06:02:07 2008 UTC

… …
67 67
68our $idle; # idle handler 68our $idle; # idle handler
69our $main; # main coroutine 69our $main; # main coroutine
70our $current; # current coroutine 70our $current; # current coroutine
71 71
72our $VERSION = 5.0; 72our $VERSION = "5.0";
73 73
74our @EXPORT = qw(async async_pool cede schedule terminate current unblock_sub); 74our @EXPORT = qw(async async_pool cede schedule terminate current unblock_sub);
75our %EXPORT_TAGS = ( 75our %EXPORT_TAGS = (
76 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)],
77); 77);
… …
135$idle = sub { 135$idle = sub {
136 require Carp; 136 require Carp;
137 Carp::croak ("FATAL: deadlock detected"); 137 Carp::croak ("FATAL: deadlock detected");
138}; 138};
139 139
140sub _cancel {
141 my ($self) = @_;
142
143 # free coroutine data and mark as destructed
144 $self->_destroy
145 or return;
146
147 # call all destruction callbacks
148 $_->(@{$self->{_status}})
149 for @{ delete $self->{_on_destroy} || [] };
150}
151
152# this coroutine is necessary because a coroutine 140# this coroutine is necessary because a coroutine
153# cannot destroy itself. 141# cannot destroy itself.
154my @destroy; 142our @destroy;
155my $manager; 143our $manager;
156 144
157$manager = new Coro sub { 145$manager = new Coro sub {
158 while () { 146 while () {
159 (shift @destroy)->_cancel 147 Coro::_cancel shift @destroy
160 while @destroy; 148 while @destroy;
161 149
162 &schedule; 150 &schedule;
163 } 151 }
164}; 152};
… …
212Similar to C<async>, but uses a coroutine pool, so you should not call 200Similar to C<async>, but uses a coroutine pool, so you should not call
213terminate or join on it (although you are allowed to), and you get a 201terminate or join on it (although you are allowed to), and you get a
214coroutine that might have executed other code already (which can be good 202coroutine that might have executed other code already (which can be good
215or bad :). 203or bad :).
216 204
217On the plus side, this function is faster than creating (and destroying) 205On the plus side, this function is about twice as fast as creating (and
218a completly new coroutine, so if you need a lot of generic coroutines in 206destroying) a completely new coroutine, so if you need a lot of generic
219quick successsion, use C<async_pool>, not C<async>. 207coroutines in quick successsion, use C<async_pool>, not C<async>.
220 208
221The code block is executed in an C<eval> context and a warning will be 209The code block is executed in an C<eval> context and a warning will be
222issued in case of an exception instead of terminating the program, as 210issued in case of an exception instead of terminating the program, as
223C<async> does. As the coroutine is being reused, stuff like C<on_destroy> 211C<async> does. As the coroutine is being reused, stuff like C<on_destroy>
224will not work in the expected way, unless you call terminate or cancel, 212will not work in the expected way, unless you call terminate or cancel,
… …
237coros as required. 225coros as required.
238 226
239If you are concerned about pooled coroutines growing a lot because a 227If you are concerned about pooled coroutines growing a lot because a
240single C<async_pool> used a lot of stackspace you can e.g. C<async_pool 228single C<async_pool> used a lot of stackspace you can e.g. C<async_pool
241{ terminate }> once per second or so to slowly replenish the pool. In 229{ terminate }> once per second or so to slowly replenish the pool. In
242addition to that, when the stacks used by a handler grows larger than 16kb 230addition to that, when the stacks used by a handler grows larger than 32kb
243(adjustable via $Coro::POOL_RSS) it will also be destroyed. 231(adjustable via $Coro::POOL_RSS) it will also be destroyed.
244 232
245=cut 233=cut
246 234
247our $POOL_SIZE = 8; 235our $POOL_SIZE = 8;
248our $POOL_RSS = 16 * 1024; 236our $POOL_RSS = 32 * 1024;
249our @async_pool; 237our @async_pool;
250 238
251sub pool_handler { 239sub pool_handler {
252 my $cb;
253
254 while () { 240 while () {
255 eval { 241 eval {
256 while () { 242 &{&_pool_handler} while 1;
257 _pool_1 $cb;
258 &$cb;
259 _pool_2 $cb;
260 &schedule;
261 }
262 }; 243 };
263 244
264 if ($@) {
265 last if $@ eq "\3async_pool terminate\2\n";
266 warn $@; 245 warn $@ if $@;
267 }
268 } 246 }
269}
270
271sub async_pool(&@) {
272 # this is also inlined into the unblock_scheduler
273 my $coro = (pop @async_pool) || new Coro \&pool_handler;
274
275 $coro->{_invoke} = [@_];
276 $coro->ready;
277
278 $coro
279} 247}
280 248
281=back 249=back
282 250
283=head2 STATIC METHODS 251=head2 STATIC METHODS
… …
339you cannot free all of them, so if a coroutine that is not the main 307you cannot free all of them, so if a coroutine that is not the main
340program calls this function, there will be some one-time resource leak. 308program calls this function, there will be some one-time resource leak.
341 309
342=cut 310=cut
343 311
344sub terminate {
345 $current->cancel (@_);
346}
347
348sub killall { 312sub killall {
349 for (Coro::State::list) { 313 for (Coro::State::list) {
350 $_->cancel 314 $_->cancel
351 if $_ != $current && UNIVERSAL::isa $_, "Coro"; 315 if $_ != $current && UNIVERSAL::isa $_, "Coro";
352 } 316 }
… …
371See C<async> and C<Coro::State::new> for additional info about the 335See C<async> and C<Coro::State::new> for additional info about the
372coroutine environment. 336coroutine environment.
373 337
374=cut 338=cut
375 339
376sub _run_coro { 340sub _terminate {
377 terminate &{+shift}; 341 terminate &{+shift};
378}
379
380sub new {
381 my $class = shift;
382
383 $class->SUPER::new (\&_run_coro, @_)
384} 342}
385 343
386=item $success = $coroutine->ready 344=item $success = $coroutine->ready
387 345
388Put the given coroutine into the end of its ready queue (there is one 346Put the given coroutine into the end of its ready queue (there is one
… …
405 363
406=cut 364=cut
407 365
408sub cancel { 366sub cancel {
409 my $self = shift; 367 my $self = shift;
410 $self->{_status} = [@_];
411 368
412 if ($current == $self) { 369 if ($current == $self) {
413 push @destroy, $self; 370 terminate @_;
414 $manager->ready;
415 &schedule while 1;
416 } else { 371 } else {
372 $self->{_status} = [@_];
417 $self->_cancel; 373 $self->_cancel;
418 } 374 }
419} 375}
376
377=item $coroutine->schedule_to
378
379Puts the current coroutine to sleep (like C<Coro::schedule>), but instead
380of continuing with the next coro from the ready queue, always switch to
381the given coroutine object (regardless of priority etc.). The readyness
382state of that coroutine isn't changed.
383
384This is an advanced method for special cases - I'd love to hear about any
385uses for this one.
386
387=item $coroutine->cede_to
388
389Like C<schedule_to>, but puts the current coroutine into the ready
390queue. This has the effect of temporarily switching to the given
391coroutine, and continuing some time later.
392
393This is an advanced method for special cases - I'd love to hear about any
394uses for this one.
420 395
421=item $coroutine->throw ([$scalar]) 396=item $coroutine->throw ([$scalar])
422 397
423If C<$throw> is specified and defined, it will be thrown as an exception 398If C<$throw> is specified and defined, it will be thrown as an exception
424inside the coroutine at the next convenient point in time. Otherwise 399inside the coroutine at the next convenient point in time. Otherwise
… …
521 496
522sub desc { 497sub desc {
523 my $old = $_[0]{desc}; 498 my $old = $_[0]{desc};
524 $_[0]{desc} = $_[1] if @_ > 1; 499 $_[0]{desc} = $_[1] if @_ > 1;
525 $old; 500 $old;
501}
502
503sub transfer {
504 require Carp;
505 Carp::croak ("You must not call ->transfer on Coro objects. Use Coro::State objects or the ->schedule_to method. Caught");
526} 506}
527 507
528=back 508=back
529 509
530=head2 GLOBAL FUNCTIONS 510=head2 GLOBAL FUNCTIONS
… …
615# return immediately and can be reused) and because we cannot cede 595# return immediately and can be reused) and because we cannot cede
616# inside an event callback. 596# inside an event callback.
617our $unblock_scheduler = new Coro sub { 597our $unblock_scheduler = new Coro sub {
618 while () { 598 while () {
619 while (my $cb = pop @unblock_queue) { 599 while (my $cb = pop @unblock_queue) {
620 # this is an inlined copy of async_pool 600 &async_pool (@$cb);
621 my $coro = (pop @async_pool) || new Coro \&pool_handler;
622 601
623 $coro->{_invoke} = $cb;
624 $coro->ready;
625 cede; # for short-lived callbacks, this reduces pressure on the coro pool 602 # for short-lived callbacks, this reduces pressure on the coro pool
603 # as the chance is very high that the async_poll coro will be back
604 # in the idle state when cede returns
605 cede;
626 } 606 }
627 schedule; # sleep well 607 schedule; # sleep well
628 } 608 }
629}; 609};
630$unblock_scheduler->{desc} = "[unblock_sub scheduler]"; 610$unblock_scheduler->{desc} = "[unblock_sub scheduler]";

Diff Legend

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