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.147 by root, Fri Oct 5 10:55:46 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
… …
224issued in case of an exception instead of terminating the program, as 219issued in case of an exception instead of terminating the program, as
225C<async> does. As the coroutine is being reused, stuff like C<on_destroy> 220C<async> does. As the coroutine is being reused, stuff like C<on_destroy>
226will not work in the expected way, unless you call terminate or cancel, 221will not work in the expected way, unless you call terminate or cancel,
227which somehow defeats the purpose of pooling. 222which somehow defeats the purpose of pooling.
228 223
229The priority will be reset to C<0> after each job, otherwise the coroutine 224The priority will be reset to C<0> after each job, tracing will be
230will be re-used "as-is". 225disabled, the description will be reset and the default output filehandle
226gets restored, so you can change alkl these. Otherwise the coroutine will
227be re-used "as-is": most notably if you change other per-coroutine global
228stuff such as C<$/> you need to revert that change, which is most simply
229done by using local as in C< local $/ >.
231 230
232The pool size is limited to 8 idle coroutines (this can be adjusted by 231The pool size is limited to 8 idle coroutines (this can be adjusted by
233changing $Coro::POOL_SIZE), and there can be as many non-idle coros as 232changing $Coro::POOL_SIZE), and there can be as many non-idle coros as
234required. 233required.
235 234
… …
316 315
317=item terminate [arg...] 316=item terminate [arg...]
318 317
319Terminates the current coroutine with the given status values (see L<cancel>). 318Terminates the current coroutine with the given status values (see L<cancel>).
320 319
320=item killall
321
322Kills/terminates/cancels all coroutines except the currently running
323one. This is useful after a fork, either in the child or the parent, as
324usually only one of them should inherit the running coroutines.
325
321=cut 326=cut
322 327
323sub terminate { 328sub terminate {
324 $current->cancel (@_); 329 $current->cancel (@_);
330}
331
332sub killall {
333 for (Coro::State::list) {
334 $_->cancel
335 if $_ != $current && UNIVERSAL::isa $_, "Coro";
336 }
325} 337}
326 338
327=back 339=back
328 340
329# dynamic methods 341# dynamic methods
… …
339Create a new coroutine and return it. When the sub returns the coroutine 351Create a new coroutine and return it. When the sub returns the coroutine
340automatically terminates as if C<terminate> with the returned values were 352automatically 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 353called. To make the coroutine run you must first put it into the ready queue
342by calling the ready method. 354by calling the ready method.
343 355
344See C<async> for additional discussion. 356See C<async> and C<Coro::State::new> for additional info about the
357coroutine environment.
345 358
346=cut 359=cut
347 360
348sub _run_coro { 361sub _run_coro {
349 terminate &{+shift}; 362 terminate &{+shift};
… …
373 386
374=cut 387=cut
375 388
376sub cancel { 389sub cancel {
377 my $self = shift; 390 my $self = shift;
378 $self->{status} = [@_]; 391 $self->{_status} = [@_];
379 392
380 if ($current == $self) { 393 if ($current == $self) {
381 push @destroy, $self; 394 push @destroy, $self;
382 $manager->ready; 395 $manager->ready;
383 &schedule while 1; 396 &schedule while 1;
… …
387} 400}
388 401
389=item $coroutine->join 402=item $coroutine->join
390 403
391Wait until the coroutine terminates and return any values given to the 404Wait until the coroutine terminates and return any values given to the
392C<terminate> or C<cancel> functions. C<join> can be called multiple times 405C<terminate> or C<cancel> functions. C<join> can be called concurrently
393from multiple coroutine. 406from multiple coroutines.
394 407
395=cut 408=cut
396 409
397sub join { 410sub join {
398 my $self = shift; 411 my $self = shift;
399 412
400 unless ($self->{status}) { 413 unless ($self->{_status}) {
401 my $current = $current; 414 my $current = $current;
402 415
403 push @{$self->{destroy_cb}}, sub { 416 push @{$self->{_on_destroy}}, sub {
404 $current->ready; 417 $current->ready;
405 undef $current; 418 undef $current;
406 }; 419 };
407 420
408 &schedule while $current; 421 &schedule while $current;
409 } 422 }
410 423
411 wantarray ? @{$self->{status}} : $self->{status}[0]; 424 wantarray ? @{$self->{_status}} : $self->{_status}[0];
412} 425}
413 426
414=item $coroutine->on_destroy (\&cb) 427=item $coroutine->on_destroy (\&cb)
415 428
416Registers a callback that is called when this coroutine gets destroyed, 429Registers a callback that is called when this coroutine gets destroyed,
… …
420=cut 433=cut
421 434
422sub on_destroy { 435sub on_destroy {
423 my ($self, $cb) = @_; 436 my ($self, $cb) = @_;
424 437
425 push @{ $self->{destroy_cb} }, $cb; 438 push @{ $self->{_on_destroy} }, $cb;
426} 439}
427 440
428=item $oldprio = $coroutine->prio ($newprio) 441=item $oldprio = $coroutine->prio ($newprio)
429 442
430Sets (or gets, if the argument is missing) the priority of the 443Sets (or gets, if the argument is missing) the priority of the
… …
454 467
455=item $olddesc = $coroutine->desc ($newdesc) 468=item $olddesc = $coroutine->desc ($newdesc)
456 469
457Sets (or gets in case the argument is missing) the description for this 470Sets (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. 471coroutine. This is just a free-form string you can associate with a coroutine.
472
473This method simply sets the C<< $coroutine->{desc} >> member to the given string. You
474can modify this member directly if you wish.
459 475
460=cut 476=cut
461 477
462sub desc { 478sub desc {
463 my $old = $_[0]{desc}; 479 my $old = $_[0]{desc};
… …
581 to allow per-thread schedulers, but Coro::State does not yet allow 597 to allow per-thread schedulers, but Coro::State does not yet allow
582 this). 598 this).
583 599
584=head1 SEE ALSO 600=head1 SEE ALSO
585 601
586Support/Utility: L<Coro::Cont>, L<Coro::Specific>, L<Coro::State>, L<Coro::Util>. 602Support/Utility: L<Coro::Specific>, L<Coro::State>, L<Coro::Util>.
587 603
588Locking/IPC: L<Coro::Signal>, L<Coro::Channel>, L<Coro::Semaphore>, L<Coro::SemaphoreSet>, L<Coro::RWLock>. 604Locking/IPC: L<Coro::Signal>, L<Coro::Channel>, L<Coro::Semaphore>, L<Coro::SemaphoreSet>, L<Coro::RWLock>.
589 605
590Event/IO: L<Coro::Timer>, L<Coro::Event>, L<Coro::Handle>, L<Coro::Socket>, L<Coro::Select>. 606Event/IO: L<Coro::Timer>, L<Coro::Event>, L<Coro::Handle>, L<Coro::Socket>, L<Coro::Select>.
591 607

Diff Legend

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