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

Comparing Coro/Coro.pm (file contents):
Revision 1.139 by root, Thu Sep 27 15:52:30 2007 UTC vs.
Revision 1.145 by root, Wed Oct 3 16:03:17 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.8'; 55our $VERSION = '4.0';
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);
… …
116=cut 116=cut
117 117
118$main->{desc} = "[main::]"; 118$main->{desc} = "[main::]";
119 119
120# maybe some other module used Coro::Specific before... 120# maybe some other module used Coro::Specific before...
121$main->{specific} = $current->{specific} 121$main->{_specific} = $current->{_specific}
122 if $current; 122 if $current;
123 123
124_set_current $main; 124_set_current $main;
125 125
126sub current() { $current } 126sub current() { $current }
… …
151 # free coroutine data and mark as destructed 151 # free coroutine data and mark as destructed
152 $self->_destroy 152 $self->_destroy
153 or return; 153 or return;
154 154
155 # call all destruction callbacks 155 # call all destruction callbacks
156 $_->(@{$self->{status}}) 156 $_->(@{$self->{_status}})
157 for @{(delete $self->{destroy_cb}) || []}; 157 for @{(delete $self->{_on_destroy}) || []};
158}
159
160sub _do_trace_sub {
161 &{$current->{_trace_sub_cb}}
162}
163
164sub _do_trace_line {
165 &{$current->{_trace_line_cb}}
166} 158}
167 159
168# this coroutine is necessary because a coroutine 160# this coroutine is necessary because a coroutine
169# cannot destroy itself. 161# cannot destroy itself.
170my @destroy; 162my @destroy;
… …
194=item async { ... } [@args...] 186=item async { ... } [@args...]
195 187
196Create a new asynchronous coroutine and return it's coroutine object 188Create a new asynchronous coroutine and return it's coroutine object
197(usually unused). When the sub returns the new coroutine is automatically 189(usually unused). When the sub returns the new coroutine is automatically
198terminated. 190terminated.
191
192See the C<Coro::State::new> constructor for info about the coroutine
193environment.
199 194
200Calling C<exit> in a coroutine will do the same as calling exit outside 195Calling C<exit> in a coroutine will do the same as calling exit outside
201the coroutine. Likewise, when the coroutine dies, the program will exit, 196the coroutine. Likewise, when the coroutine dies, the program will exit,
202just as it would in the main program. 197just as it would in the main program.
203 198
… …
316 311
317=item terminate [arg...] 312=item terminate [arg...]
318 313
319Terminates the current coroutine with the given status values (see L<cancel>). 314Terminates the current coroutine with the given status values (see L<cancel>).
320 315
316=item killall
317
318Kills/terminates/cancels all coroutines except the currently running
319one. This is useful after a fork, either in the child or the parent, as
320usually only one of them should inherit the running coroutines.
321
321=cut 322=cut
322 323
323sub terminate { 324sub terminate {
324 $current->cancel (@_); 325 $current->cancel (@_);
326}
327
328sub killall {
329 for (Coro::State::list) {
330 $_->cancel
331 if $_ != $current && UNIVERSAL::isa $_, "Coro";
332 }
325} 333}
326 334
327=back 335=back
328 336
329# dynamic methods 337# dynamic methods
… …
339Create a new coroutine and return it. When the sub returns the coroutine 347Create a new coroutine and return it. When the sub returns the coroutine
340automatically terminates as if C<terminate> with the returned values were 348automatically terminates as if C<terminate> with the returned values were
341called. To make the coroutine run you must first put it into the ready queue 349called. To make the coroutine run you must first put it into the ready queue
342by calling the ready method. 350by calling the ready method.
343 351
344See C<async> for additional discussion. 352See C<async> and C<Coro::State::new> for additional info about the
353coroutine environment.
345 354
346=cut 355=cut
347 356
348sub _run_coro { 357sub _run_coro {
349 terminate &{+shift}; 358 terminate &{+shift};
… …
373 382
374=cut 383=cut
375 384
376sub cancel { 385sub cancel {
377 my $self = shift; 386 my $self = shift;
378 $self->{status} = [@_]; 387 $self->{_status} = [@_];
379 388
380 if ($current == $self) { 389 if ($current == $self) {
381 push @destroy, $self; 390 push @destroy, $self;
382 $manager->ready; 391 $manager->ready;
383 &schedule while 1; 392 &schedule while 1;
… …
387} 396}
388 397
389=item $coroutine->join 398=item $coroutine->join
390 399
391Wait until the coroutine terminates and return any values given to the 400Wait until the coroutine terminates and return any values given to the
392C<terminate> or C<cancel> functions. C<join> can be called multiple times 401C<terminate> or C<cancel> functions. C<join> can be called concurrently
393from multiple coroutine. 402from multiple coroutines.
394 403
395=cut 404=cut
396 405
397sub join { 406sub join {
398 my $self = shift; 407 my $self = shift;
399 408
400 unless ($self->{status}) { 409 unless ($self->{_status}) {
401 my $current = $current; 410 my $current = $current;
402 411
403 push @{$self->{destroy_cb}}, sub { 412 push @{$self->{_on_destroy}}, sub {
404 $current->ready; 413 $current->ready;
405 undef $current; 414 undef $current;
406 }; 415 };
407 416
408 &schedule while $current; 417 &schedule while $current;
409 } 418 }
410 419
411 wantarray ? @{$self->{status}} : $self->{status}[0]; 420 wantarray ? @{$self->{_status}} : $self->{_status}[0];
412} 421}
413 422
414=item $coroutine->on_destroy (\&cb) 423=item $coroutine->on_destroy (\&cb)
415 424
416Registers a callback that is called when this coroutine gets destroyed, 425Registers a callback that is called when this coroutine gets destroyed,
… …
420=cut 429=cut
421 430
422sub on_destroy { 431sub on_destroy {
423 my ($self, $cb) = @_; 432 my ($self, $cb) = @_;
424 433
425 push @{ $self->{destroy_cb} }, $cb; 434 push @{ $self->{_on_destroy} }, $cb;
426} 435}
427 436
428=item $oldprio = $coroutine->prio ($newprio) 437=item $oldprio = $coroutine->prio ($newprio)
429 438
430Sets (or gets, if the argument is missing) the priority of the 439Sets (or gets, if the argument is missing) the priority of the
… …
454 463
455=item $olddesc = $coroutine->desc ($newdesc) 464=item $olddesc = $coroutine->desc ($newdesc)
456 465
457Sets (or gets in case the argument is missing) the description for this 466Sets (or gets in case the argument is missing) the description for this
458coroutine. This is just a free-form string you can associate with a coroutine. 467coroutine. This is just a free-form string you can associate with a coroutine.
468
469This method simply sets the C<< $coroutine->{desc} >> member to the given string. You
470can modify this member directly if you wish.
459 471
460=cut 472=cut
461 473
462sub desc { 474sub desc {
463 my $old = $_[0]{desc}; 475 my $old = $_[0]{desc};

Diff Legend

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