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

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

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines