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

Comparing Coro/Coro.pm (file contents):
Revision 1.20 by root, Sat Jul 21 18:21:45 2001 UTC vs.
Revision 1.144 by root, Wed Oct 3 01:48:05 2007 UTC

8 8
9 async { 9 async {
10 # some asynchronous thread of execution 10 # some asynchronous thread of execution
11 }; 11 };
12 12
13 # alternatively create an async process like this: 13 # alternatively create an async coroutine like this:
14 14
15 sub some_func : Coro { 15 sub some_func : Coro {
16 # some more async code 16 # some more async code
17 } 17 }
18 18
19 yield; 19 cede;
20 20
21=head1 DESCRIPTION 21=head1 DESCRIPTION
22 22
23This module collection manages coroutines. Coroutines are similar to 23This module collection manages coroutines. Coroutines are similar
24Threads but don't run in parallel. 24to threads but don't run in parallel at the same time even on SMP
25machines. The specific flavor of coroutine used in this module also
26guarantees you that it will not switch between coroutines unless
27necessary, at easily-identified points in your program, so locking and
28parallel access are rarely an issue, making coroutine programming much
29safer than threads programming.
25 30
26This module is still experimental, see the BUGS section below. 31(Perl, however, does not natively support real threads but instead does a
32very slow and memory-intensive emulation of processes using threads. This
33is a performance win on Windows machines, and a loss everywhere else).
27 34
28In this module, coroutines are defined as "callchain + lexical variables 35In this module, coroutines are defined as "callchain + lexical variables +
29+ @_ + $_ + $@ + $^W), that is, a coroutine has it's own callchain, it's 36@_ + $_ + $@ + $/ + C stack), that is, a coroutine has its own callchain,
30own set of lexicals and it's own set of perl's most important global 37its own set of lexicals and its own set of perls most important global
31variables. 38variables.
32 39
33=cut 40=cut
34 41
35package Coro; 42package Coro;
36 43
44use strict;
45no warnings "uninitialized";
46
37use Coro::State; 47use Coro::State;
38 48
39use base Exporter; 49use base qw(Coro::State Exporter);
40 50
41$VERSION = 0.10; 51our $idle; # idle handler
52our $main; # main coroutine
53our $current; # current coroutine
42 54
55our $VERSION = '4.0';
56
43@EXPORT = qw(async yield schedule terminate current); 57our @EXPORT = qw(async async_pool cede schedule terminate current unblock_sub);
44@EXPORT_OK = qw($current); 58our %EXPORT_TAGS = (
59 prio => [qw(PRIO_MAX PRIO_HIGH PRIO_NORMAL PRIO_LOW PRIO_IDLE PRIO_MIN)],
60);
61our @EXPORT_OK = (@{$EXPORT_TAGS{prio}}, qw(nready));
45 62
46{ 63{
47 my @async; 64 my @async;
65 my $init;
48 66
49 # this way of handling attributes simply is NOT scalable ;() 67 # this way of handling attributes simply is NOT scalable ;()
50 sub import { 68 sub import {
69 no strict 'refs';
70
51 Coro->export_to_level(1, @_); 71 Coro->export_to_level (1, @_);
72
52 my $old = *{(caller)[0]."::MODIFY_CODE_ATTRIBUTES"}{CODE}; 73 my $old = *{(caller)[0]."::MODIFY_CODE_ATTRIBUTES"}{CODE};
53 *{(caller)[0]."::MODIFY_CODE_ATTRIBUTES"} = sub { 74 *{(caller)[0]."::MODIFY_CODE_ATTRIBUTES"} = sub {
54 my ($package, $ref) = (shift, shift); 75 my ($package, $ref) = (shift, shift);
55 my @attrs; 76 my @attrs;
56 for (@_) { 77 for (@_) {
57 if ($_ eq "Coro") { 78 if ($_ eq "Coro") {
58 push @async, $ref; 79 push @async, $ref;
80 unless ($init++) {
81 eval q{
82 sub INIT {
83 &async(pop @async) while @async;
84 }
85 };
86 }
59 } else { 87 } else {
60 push @attrs, $_; 88 push @attrs, $_;
61 } 89 }
62 } 90 }
63 return $old ? $old->($package, $ref, @attrs) : @attrs; 91 return $old ? $old->($package, $ref, @attrs) : @attrs;
64 }; 92 };
65 } 93 }
66 94
67 sub INIT {
68 &async(pop @async) while @async;
69 }
70} 95}
96
97=over 4
71 98
72=item $main 99=item $main
73 100
74This coroutine represents the main program. 101This coroutine represents the main program.
75 102
76=cut 103=cut
77 104
78our $main = new Coro; 105$main = new Coro;
79 106
80=item $current (or as function: current) 107=item $current (or as function: current)
81 108
82The current coroutine (the last coroutine switched to). The initial value is C<$main> (of course). 109The current coroutine (the last coroutine switched to). The initial value
110is C<$main> (of course).
83 111
112This variable is B<strictly> I<read-only>. It is provided for performance
113reasons. If performance is not essential you are encouraged to use the
114C<Coro::current> function instead.
115
84=cut 116=cut
117
118$main->{desc} = "[main::]";
85 119
86# maybe some other module used Coro::Specific before... 120# maybe some other module used Coro::Specific before...
87if ($current) {
88 $main->{specific} = $current->{specific}; 121$main->{_specific} = $current->{_specific}
89} 122 if $current;
90 123
91our $current = $main; 124_set_current $main;
92 125
93sub current() { $current } 126sub current() { $current }
94 127
95=item $idle 128=item $idle
96 129
97The coroutine to switch to when no other coroutine is running. The default 130A callback that is called whenever the scheduler finds no ready coroutines
98implementation prints "FATAL: deadlock detected" and exits. 131to run. The default implementation prints "FATAL: deadlock detected" and
132exits, because the program has no other way to continue.
99 133
100=cut 134This hook is overwritten by modules such as C<Coro::Timer> and
135C<Coro::Event> to wait on an external event that hopefully wake up a
136coroutine so the scheduler can run it.
101 137
102# should be done using priorities :( 138Please note that if your callback recursively invokes perl (e.g. for event
103our $idle = new Coro sub { 139handlers), then it must be prepared to be called recursively.
104 print STDERR "FATAL: deadlock detected\n"; 140
105 exit(51); 141=cut
142
143$idle = sub {
144 require Carp;
145 Carp::croak ("FATAL: deadlock detected");
106}; 146};
107 147
108# we really need priorities... 148sub _cancel {
109my @ready; # the ready queue. hehe, rather broken ;) 149 my ($self) = @_;
150
151 # free coroutine data and mark as destructed
152 $self->_destroy
153 or return;
154
155 # call all destruction callbacks
156 $_->(@{$self->{_status}})
157 for @{(delete $self->{_on_destroy}) || []};
158}
159
160# this coroutine is necessary because a coroutine
161# cannot destroy itself.
162my @destroy;
163my $manager;
164
165$manager = new Coro sub {
166 while () {
167 (shift @destroy)->_cancel
168 while @destroy;
169
170 &schedule;
171 }
172};
173$manager->desc ("[coro manager]");
174$manager->prio (PRIO_MAX);
110 175
111# static methods. not really. 176# static methods. not really.
112 177
178=back
179
113=head2 STATIC METHODS 180=head2 STATIC METHODS
114 181
115Static methods are actually functions that operate on the current process only. 182Static methods are actually functions that operate on the current coroutine only.
116 183
117=over 4 184=over 4
118 185
119=item async { ... } [@args...] 186=item async { ... } [@args...]
120 187
121Create a new asynchronous process and return it's process object 188Create a new asynchronous coroutine and return it's coroutine object
122(usually unused). When the sub returns the new process is automatically 189(usually unused). When the sub returns the new coroutine is automatically
123terminated. 190terminated.
191
192Calling C<exit> in a coroutine will do the same as calling exit outside
193the coroutine. Likewise, when the coroutine dies, the program will exit,
194just as it would in the main program.
124 195
125 # create a new coroutine that just prints its arguments 196 # create a new coroutine that just prints its arguments
126 async { 197 async {
127 print "@_\n"; 198 print "@_\n";
128 } 1,2,3,4; 199 } 1,2,3,4;
129 200
130The coderef you submit MUST NOT be a closure that refers to variables
131in an outer scope. This does NOT work. Pass arguments into it instead.
132
133=cut 201=cut
134 202
135sub async(&@) { 203sub async(&@) {
136 my $pid = new Coro @_; 204 my $coro = new Coro @_;
137 $pid->ready; 205 $coro->ready;
138 $pid; 206 $coro
207}
208
209=item async_pool { ... } [@args...]
210
211Similar to C<async>, but uses a coroutine pool, so you should not call
212terminate or join (although you are allowed to), and you get a coroutine
213that might have executed other code already (which can be good or bad :).
214
215Also, the block is executed in an C<eval> context and a warning will be
216issued in case of an exception instead of terminating the program, as
217C<async> does. As the coroutine is being reused, stuff like C<on_destroy>
218will not work in the expected way, unless you call terminate or cancel,
219which somehow defeats the purpose of pooling.
220
221The priority will be reset to C<0> after each job, otherwise the coroutine
222will be re-used "as-is".
223
224The pool size is limited to 8 idle coroutines (this can be adjusted by
225changing $Coro::POOL_SIZE), and there can be as many non-idle coros as
226required.
227
228If you are concerned about pooled coroutines growing a lot because a
229single C<async_pool> used a lot of stackspace you can e.g. C<async_pool
230{ terminate }> once per second or so to slowly replenish the pool. In
231addition to that, when the stacks used by a handler grows larger than 16kb
232(adjustable with $Coro::POOL_RSS) it will also exit.
233
234=cut
235
236our $POOL_SIZE = 8;
237our $POOL_RSS = 16 * 1024;
238our @async_pool;
239
240sub pool_handler {
241 my $cb;
242
243 while () {
244 eval {
245 while () {
246 _pool_1 $cb;
247 &$cb;
248 _pool_2 $cb;
249 &schedule;
250 }
251 };
252
253 last if $@ eq "\3terminate\2\n";
254 warn $@ if $@;
255 }
256}
257
258sub async_pool(&@) {
259 # this is also inlined into the unlock_scheduler
260 my $coro = (pop @async_pool) || new Coro \&pool_handler;
261
262 $coro->{_invoke} = [@_];
263 $coro->ready;
264
265 $coro
139} 266}
140 267
141=item schedule 268=item schedule
142 269
143Calls the scheduler. Please note that the current process will not be put 270Calls the scheduler. Please note that the current coroutine will not be put
144into the ready queue, so calling this function usually means you will 271into the ready queue, so calling this function usually means you will
145never be called again. 272never be called again unless something else (e.g. an event handler) calls
273ready.
146 274
147=cut 275The canonical way to wait on external events is this:
148 276
149my $prev; 277 {
278 # remember current coroutine
279 my $current = $Coro::current;
150 280
151sub schedule { 281 # register a hypothetical event handler
152 # should be done using priorities :( 282 on_event_invoke sub {
153 ($prev, $current) = ($current, shift @ready || $idle); 283 # wake up sleeping coroutine
154 Coro::State::transfer($prev, $current);
155}
156
157=item yield
158
159Yield to other processes. This function puts the current process into the
160ready queue and calls C<schedule>.
161
162=cut
163
164sub yield {
165 $current->ready; 284 $current->ready;
166 &schedule; 285 undef $current;
167} 286 };
168 287
288 # call schedule until event occurred.
289 # in case we are woken up for other reasons
290 # (current still defined), loop.
291 Coro::schedule while $current;
292 }
293
294=item cede
295
296"Cede" to other coroutines. This function puts the current coroutine into the
297ready queue and calls C<schedule>, which has the effect of giving up the
298current "timeslice" to other coroutines of the same or higher priority.
299
300Returns true if at least one coroutine switch has happened.
301
302=item Coro::cede_notself
303
304Works like cede, but is not exported by default and will cede to any
305coroutine, regardless of priority, once.
306
307Returns true if at least one coroutine switch has happened.
308
169=item terminate 309=item terminate [arg...]
170 310
171Terminates the current process. 311Terminates the current coroutine with the given status values (see L<cancel>).
172 312
173Future versions of this function will allow result arguments. 313=item killall
314
315Kills/terminates/cancels all coroutines except the currently running
316one. This is useful after a fork, either in the child or the parent, as
317usually only one of them should inherit the running coroutines.
174 318
175=cut 319=cut
176 320
177sub terminate { 321sub terminate {
178 $current->{_results} = [@_]; 322 $current->cancel (@_);
179 &schedule; 323}
324
325sub killall {
326 for (Coro::State::list) {
327 $_->cancel
328 if $_ != $current && UNIVERSAL::isa $_, "Coro";
329 }
180} 330}
181 331
182=back 332=back
183 333
184# dynamic methods 334# dynamic methods
185 335
186=head2 PROCESS METHODS 336=head2 COROUTINE METHODS
187 337
188These are the methods you can call on process objects. 338These are the methods you can call on coroutine objects.
189 339
190=over 4 340=over 4
191 341
192=item new Coro \&sub [, @args...] 342=item new Coro \&sub [, @args...]
193 343
194Create a new process and return it. When the sub returns the process 344Create a new coroutine and return it. When the sub returns the coroutine
195automatically terminates. To start the process you must first put it into 345automatically terminates as if C<terminate> with the returned values were
346called. To make the coroutine run you must first put it into the ready queue
196the ready queue by calling the ready method. 347by calling the ready method.
197 348
198The coderef you submit MUST NOT be a closure that refers to variables 349See C<async> for additional discussion.
199in an outer scope. This does NOT work. Pass arguments into it instead.
200 350
201=cut 351=cut
202 352
203sub _newcoro { 353sub _run_coro {
204 terminate &{+shift}; 354 terminate &{+shift};
205} 355}
206 356
207sub new { 357sub new {
208 my $class = shift; 358 my $class = shift;
209 bless {
210 _coro_state => (new Coro::State $_[0] && \&_newcoro, @_),
211 }, $class;
212}
213 359
214=item $process->ready 360 $class->SUPER::new (\&_run_coro, @_)
361}
215 362
216Put the current process into the ready queue. 363=item $success = $coroutine->ready
217 364
218=cut 365Put the given coroutine into the ready queue (according to it's priority)
366and return true. If the coroutine is already in the ready queue, do nothing
367and return false.
219 368
220sub ready { 369=item $is_ready = $coroutine->is_ready
221 push @ready, $_[0]; 370
371Return wether the coroutine is currently the ready queue or not,
372
373=item $coroutine->cancel (arg...)
374
375Terminates the given coroutine and makes it return the given arguments as
376status (default: the empty list). Never returns if the coroutine is the
377current coroutine.
378
379=cut
380
381sub cancel {
382 my $self = shift;
383 $self->{_status} = [@_];
384
385 if ($current == $self) {
386 push @destroy, $self;
387 $manager->ready;
388 &schedule while 1;
389 } else {
390 $self->_cancel;
391 }
392}
393
394=item $coroutine->join
395
396Wait until the coroutine terminates and return any values given to the
397C<terminate> or C<cancel> functions. C<join> can be called concurrently
398from multiple coroutines.
399
400=cut
401
402sub join {
403 my $self = shift;
404
405 unless ($self->{_status}) {
406 my $current = $current;
407
408 push @{$self->{_on_destroy}}, sub {
409 $current->ready;
410 undef $current;
411 };
412
413 &schedule while $current;
414 }
415
416 wantarray ? @{$self->{_status}} : $self->{_status}[0];
417}
418
419=item $coroutine->on_destroy (\&cb)
420
421Registers a callback that is called when this coroutine gets destroyed,
422but before it is joined. The callback gets passed the terminate arguments,
423if any.
424
425=cut
426
427sub on_destroy {
428 my ($self, $cb) = @_;
429
430 push @{ $self->{_on_destroy} }, $cb;
431}
432
433=item $oldprio = $coroutine->prio ($newprio)
434
435Sets (or gets, if the argument is missing) the priority of the
436coroutine. Higher priority coroutines get run before lower priority
437coroutines. Priorities are small signed integers (currently -4 .. +3),
438that you can refer to using PRIO_xxx constants (use the import tag :prio
439to get then):
440
441 PRIO_MAX > PRIO_HIGH > PRIO_NORMAL > PRIO_LOW > PRIO_IDLE > PRIO_MIN
442 3 > 1 > 0 > -1 > -3 > -4
443
444 # set priority to HIGH
445 current->prio(PRIO_HIGH);
446
447The idle coroutine ($Coro::idle) always has a lower priority than any
448existing coroutine.
449
450Changing the priority of the current coroutine will take effect immediately,
451but changing the priority of coroutines in the ready queue (but not
452running) will only take effect after the next schedule (of that
453coroutine). This is a bug that will be fixed in some future version.
454
455=item $newprio = $coroutine->nice ($change)
456
457Similar to C<prio>, but subtract the given value from the priority (i.e.
458higher values mean lower priority, just as in unix).
459
460=item $olddesc = $coroutine->desc ($newdesc)
461
462Sets (or gets in case the argument is missing) the description for this
463coroutine. This is just a free-form string you can associate with a coroutine.
464
465This method simply sets the C<< $coroutine->{desc} >> member to the given string. You
466can modify this member directly if you wish.
467
468=cut
469
470sub desc {
471 my $old = $_[0]{desc};
472 $_[0]{desc} = $_[1] if @_ > 1;
473 $old;
222} 474}
223 475
224=back 476=back
225 477
478=head2 GLOBAL FUNCTIONS
479
480=over 4
481
482=item Coro::nready
483
484Returns the number of coroutines that are currently in the ready state,
485i.e. that can be switched to. The value C<0> means that the only runnable
486coroutine is the currently running one, so C<cede> would have no effect,
487and C<schedule> would cause a deadlock unless there is an idle handler
488that wakes up some coroutines.
489
490=item my $guard = Coro::guard { ... }
491
492This creates and returns a guard object. Nothing happens until the object
493gets destroyed, in which case the codeblock given as argument will be
494executed. This is useful to free locks or other resources in case of a
495runtime error or when the coroutine gets canceled, as in both cases the
496guard block will be executed. The guard object supports only one method,
497C<< ->cancel >>, which will keep the codeblock from being executed.
498
499Example: set some flag and clear it again when the coroutine gets canceled
500or the function returns:
501
502 sub do_something {
503 my $guard = Coro::guard { $busy = 0 };
504 $busy = 1;
505
506 # do something that requires $busy to be true
507 }
508
509=cut
510
511sub guard(&) {
512 bless \(my $cb = $_[0]), "Coro::guard"
513}
514
515sub Coro::guard::cancel {
516 ${$_[0]} = sub { };
517}
518
519sub Coro::guard::DESTROY {
520 ${$_[0]}->();
521}
522
523
524=item unblock_sub { ... }
525
526This utility function takes a BLOCK or code reference and "unblocks" it,
527returning the new coderef. This means that the new coderef will return
528immediately without blocking, returning nothing, while the original code
529ref will be called (with parameters) from within its own coroutine.
530
531The reason this function exists is that many event libraries (such as the
532venerable L<Event|Event> module) are not coroutine-safe (a weaker form
533of thread-safety). This means you must not block within event callbacks,
534otherwise you might suffer from crashes or worse.
535
536This function allows your callbacks to block by executing them in another
537coroutine where it is safe to block. One example where blocking is handy
538is when you use the L<Coro::AIO|Coro::AIO> functions to save results to
539disk.
540
541In short: simply use C<unblock_sub { ... }> instead of C<sub { ... }> when
542creating event callbacks that want to block.
543
544=cut
545
546our @unblock_queue;
547
548# we create a special coro because we want to cede,
549# to reduce pressure on the coro pool (because most callbacks
550# return immediately and can be reused) and because we cannot cede
551# inside an event callback.
552our $unblock_scheduler = new Coro sub {
553 while () {
554 while (my $cb = pop @unblock_queue) {
555 # this is an inlined copy of async_pool
556 my $coro = (pop @async_pool) || new Coro \&pool_handler;
557
558 $coro->{_invoke} = $cb;
559 $coro->ready;
560 cede; # for short-lived callbacks, this reduces pressure on the coro pool
561 }
562 schedule; # sleep well
563 }
564};
565$unblock_scheduler->desc ("[unblock_sub scheduler]");
566
567sub unblock_sub(&) {
568 my $cb = shift;
569
570 sub {
571 unshift @unblock_queue, [$cb, @_];
572 $unblock_scheduler->ready;
573 }
574}
575
576=back
577
226=cut 578=cut
227 579
2281; 5801;
229 581
230=head1 BUGS/LIMITATIONS 582=head1 BUGS/LIMITATIONS
231 583
232 - could be faster, especially when the core would introduce special 584 - you must make very sure that no coro is still active on global
233 support for coroutines (like it does for threads). 585 destruction. very bad things might happen otherwise (usually segfaults).
234 - there is still a memleak on coroutine termination that I could not 586
235 identify. Could be as small as a single SV.
236 - this module is not well-tested.
237 - if variables or arguments "disappear" (become undef) or become
238 corrupted please contact the author so he cen iron out the
239 remaining bugs.
240 - this module is not thread-safe. You must only ever use this module from 587 - this module is not thread-safe. You should only ever use this module
241 the same thread (this requirement might be loosened in the future to 588 from the same thread (this requirement might be loosened in the future
242 allow per-thread schedulers, but Coro::State does not yet allow this). 589 to allow per-thread schedulers, but Coro::State does not yet allow
590 this).
243 591
244=head1 SEE ALSO 592=head1 SEE ALSO
245 593
246L<Coro::Channel>, L<Coro::Cont>, L<Coro::Specific>, L<Coro::Semaphore>, 594Support/Utility: L<Coro::Cont>, L<Coro::Specific>, L<Coro::State>, L<Coro::Util>.
247L<Coro::Signal>, L<Coro::State>, L<Coro::Event>. 595
596Locking/IPC: L<Coro::Signal>, L<Coro::Channel>, L<Coro::Semaphore>, L<Coro::SemaphoreSet>, L<Coro::RWLock>.
597
598Event/IO: L<Coro::Timer>, L<Coro::Event>, L<Coro::Handle>, L<Coro::Socket>, L<Coro::Select>.
599
600Embedding: L<Coro:MakeMaker>
248 601
249=head1 AUTHOR 602=head1 AUTHOR
250 603
251 Marc Lehmann <pcg@goof.com> 604 Marc Lehmann <schmorp@schmorp.de>
252 http://www.goof.com/pcg/marc/ 605 http://home.schmorp.de/
253 606
254=cut 607=cut
255 608

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines